home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / SLAX 6.0.8 / slax-6.0.8.iso / slax / base / 006-devel.lzm / usr / include / arts / artsmoduleseffects.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-10-24  |  131.4 KB  |  3,461 lines
  1. /* this file was generated by the MCOP idl compiler - DO NOT EDIT */
  2.  
  3. #ifndef ARTSMODULESEFFECTS_H
  4. #define ARTSMODULESEFFECTS_H
  5.  
  6. #include "common.h"
  7.  
  8. #include "arts_export.h"
  9.  
  10. // includes of other idl definitions
  11. #include "artsflow.h"
  12. #include "artsgui.h"
  13. #include "artsmodulescommon.h"
  14. #include "artsmidi.h"
  15. #include "artsmodulessynth.h"
  16.  
  17. namespace Arts {
  18. class StereoToMono;
  19. class MonoToStereo;
  20. class StereoBalance;
  21. class StereoBalanceGuiFactory;
  22. class FiveBandMonoComplexEQ;
  23. class FiveBandMonoComplexEQGuiFactory;
  24. class Synth_VOICE_REMOVAL;
  25. class VoiceRemovalGuiFactory;
  26. class Synth_STEREO_COMPRESSOR;
  27. class StereoCompressorGuiFactory;
  28. class Synth_STEREO_PITCH_SHIFT;
  29. class Synth_STEREO_PITCH_SHIFT_FFT;
  30. class Synth_STEREO_FIR_EQUALIZER;
  31. class StereoFirEqualizerGuiFactory;
  32. class Synth_FREEVERB;
  33. class FreeverbGuiFactory;
  34. class Effect_WAVECAPTURE;
  35. class StereoVolumeControlGui;
  36. class StereoVolumeControlGuiFactory;
  37.  
  38. class ARTS_EXPORT StereoToMono_base : virtual public Arts::SynthModule_base {
  39. public:
  40.     static unsigned long _IID; // interface ID
  41.  
  42.     static StereoToMono_base *_create(const std::string& subClass = "Arts::StereoToMono");
  43.     static StereoToMono_base *_fromString(const std::string& objectref);
  44.     static StereoToMono_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  45.  
  46.     static StereoToMono_base *_fromDynamicCast(const Arts::Object& object);
  47.     inline StereoToMono_base *_copy() {
  48.         assert(_refCnt > 0);
  49.         _refCnt++;
  50.         return this;
  51.     }
  52.  
  53.     virtual std::vector<std::string> _defaultPortsIn() const;
  54.     virtual std::vector<std::string> _defaultPortsOut() const;
  55.  
  56.     void *_cast(unsigned long iid);
  57.  
  58.     virtual float pan() = 0;
  59.     virtual void pan(float newValue) = 0;
  60. };
  61.  
  62. class ARTS_EXPORT StereoToMono_stub : virtual public StereoToMono_base, virtual public Arts::SynthModule_stub {
  63. protected:
  64.     StereoToMono_stub();
  65.  
  66. public:
  67.     StereoToMono_stub(Arts::Connection *connection, long objectID);
  68.  
  69.     float pan();
  70.     void pan(float newValue);
  71. };
  72.  
  73. class ARTS_EXPORT StereoToMono_skel : virtual public StereoToMono_base, virtual public Arts::SynthModule_skel {
  74. protected:
  75.     // variables for streams
  76.     float *inleft;                            // incoming stream
  77.     float *inright;                           // incoming stream
  78.     float *outmono;                           // outgoing stream
  79.  
  80. protected:
  81.     // emitters for change notifications
  82.     inline void pan_changed(float newValue) {
  83.         _emit_changed("pan_changed",newValue);
  84.     }
  85.  
  86. public:
  87.     StereoToMono_skel();
  88.  
  89.     static std::string _interfaceNameSkel();
  90.     std::string _interfaceName();
  91.     bool _isCompatibleWith(const std::string& interfacename);
  92.     void _buildMethodTable();
  93.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  94. };
  95.  
  96. }
  97. #include "reference.h"
  98. namespace Arts {
  99. class ARTS_EXPORT StereoToMono : public Arts::Object {
  100. private:
  101.     static Arts::Object_base* _Creator();
  102.     StereoToMono_base *_cache;
  103.     inline StereoToMono_base *_method_call() {
  104.         _pool->checkcreate();
  105.         if(_pool->base) {
  106.             _cache=(StereoToMono_base *)_pool->base->_cast(StereoToMono_base::_IID);
  107.             assert(_cache);
  108.         }
  109.         return _cache;
  110.     }
  111.  
  112. protected:
  113.     inline StereoToMono(StereoToMono_base* b) : Arts::Object(b), _cache(0) {}
  114.  
  115.  
  116. public:
  117.     typedef StereoToMono_base _base_class;
  118.  
  119.     inline StereoToMono() : Arts::Object(_Creator), _cache(0) {}
  120.     inline StereoToMono(const Arts::SubClass& s) :
  121.         Arts::Object(StereoToMono_base::_create(s.string())), _cache(0) {}
  122.     inline StereoToMono(const Arts::Reference &r) :
  123.         Arts::Object(r.isString()?(StereoToMono_base::_fromString(r.string())):(StereoToMono_base::_fromReference(r.reference(),true))), _cache(0) {}
  124.     inline StereoToMono(const Arts::DynamicCast& c) : Arts::Object(StereoToMono_base::_fromDynamicCast(c.object())), _cache(0) {}
  125.     inline StereoToMono(const StereoToMono& target) : Arts::Object(target._pool), _cache(target._cache) {}
  126.     inline StereoToMono(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  127.     inline static StereoToMono null() {return StereoToMono((StereoToMono_base*)0);}
  128.     inline static StereoToMono _from_base(StereoToMono_base* b) {return StereoToMono(b);}
  129.     inline StereoToMono& operator=(const StereoToMono& target) {
  130.         if (_pool == target._pool) return *this;
  131.         _pool->Dec();
  132.         _pool = target._pool;
  133.         _cache = target._cache;
  134.         _pool->Inc();
  135.         return *this;
  136.     }
  137.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  138.     inline StereoToMono_base* _base() {return _cache?_cache:_method_call();}
  139.  
  140.     inline Arts::AutoSuspendState autoSuspend();
  141.     inline void start();
  142.     inline void stop();
  143.     inline void streamInit();
  144.     inline void streamStart();
  145.     inline void streamEnd();
  146.     inline float pan();
  147.     inline void pan(float _newValue);
  148. };
  149.  
  150. class ARTS_EXPORT MonoToStereo_base : virtual public Arts::SynthModule_base {
  151. public:
  152.     static unsigned long _IID; // interface ID
  153.  
  154.     static MonoToStereo_base *_create(const std::string& subClass = "Arts::MonoToStereo");
  155.     static MonoToStereo_base *_fromString(const std::string& objectref);
  156.     static MonoToStereo_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  157.  
  158.     static MonoToStereo_base *_fromDynamicCast(const Arts::Object& object);
  159.     inline MonoToStereo_base *_copy() {
  160.         assert(_refCnt > 0);
  161.         _refCnt++;
  162.         return this;
  163.     }
  164.  
  165.     virtual std::vector<std::string> _defaultPortsIn() const;
  166.     virtual std::vector<std::string> _defaultPortsOut() const;
  167.  
  168.     void *_cast(unsigned long iid);
  169.  
  170.     virtual float pan() = 0;
  171.     virtual void pan(float newValue) = 0;
  172. };
  173.  
  174. class ARTS_EXPORT MonoToStereo_stub : virtual public MonoToStereo_base, virtual public Arts::SynthModule_stub {
  175. protected:
  176.     MonoToStereo_stub();
  177.  
  178. public:
  179.     MonoToStereo_stub(Arts::Connection *connection, long objectID);
  180.  
  181.     float pan();
  182.     void pan(float newValue);
  183. };
  184.  
  185. class ARTS_EXPORT MonoToStereo_skel : virtual public MonoToStereo_base, virtual public Arts::SynthModule_skel {
  186. protected:
  187.     // variables for streams
  188.     float *inmono;                            // incoming stream
  189.     float *outleft;                           // outgoing stream
  190.     float *outright;                          // outgoing stream
  191.  
  192. protected:
  193.     // emitters for change notifications
  194.     inline void pan_changed(float newValue) {
  195.         _emit_changed("pan_changed",newValue);
  196.     }
  197.  
  198. public:
  199.     MonoToStereo_skel();
  200.  
  201.     static std::string _interfaceNameSkel();
  202.     std::string _interfaceName();
  203.     bool _isCompatibleWith(const std::string& interfacename);
  204.     void _buildMethodTable();
  205.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  206. };
  207.  
  208. }
  209. #include "reference.h"
  210. namespace Arts {
  211. class ARTS_EXPORT MonoToStereo : public Arts::Object {
  212. private:
  213.     static Arts::Object_base* _Creator();
  214.     MonoToStereo_base *_cache;
  215.     inline MonoToStereo_base *_method_call() {
  216.         _pool->checkcreate();
  217.         if(_pool->base) {
  218.             _cache=(MonoToStereo_base *)_pool->base->_cast(MonoToStereo_base::_IID);
  219.             assert(_cache);
  220.         }
  221.         return _cache;
  222.     }
  223.  
  224. protected:
  225.     inline MonoToStereo(MonoToStereo_base* b) : Arts::Object(b), _cache(0) {}
  226.  
  227.  
  228. public:
  229.     typedef MonoToStereo_base _base_class;
  230.  
  231.     inline MonoToStereo() : Arts::Object(_Creator), _cache(0) {}
  232.     inline MonoToStereo(const Arts::SubClass& s) :
  233.         Arts::Object(MonoToStereo_base::_create(s.string())), _cache(0) {}
  234.     inline MonoToStereo(const Arts::Reference &r) :
  235.         Arts::Object(r.isString()?(MonoToStereo_base::_fromString(r.string())):(MonoToStereo_base::_fromReference(r.reference(),true))), _cache(0) {}
  236.     inline MonoToStereo(const Arts::DynamicCast& c) : Arts::Object(MonoToStereo_base::_fromDynamicCast(c.object())), _cache(0) {}
  237.     inline MonoToStereo(const MonoToStereo& target) : Arts::Object(target._pool), _cache(target._cache) {}
  238.     inline MonoToStereo(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  239.     inline static MonoToStereo null() {return MonoToStereo((MonoToStereo_base*)0);}
  240.     inline static MonoToStereo _from_base(MonoToStereo_base* b) {return MonoToStereo(b);}
  241.     inline MonoToStereo& operator=(const MonoToStereo& target) {
  242.         if (_pool == target._pool) return *this;
  243.         _pool->Dec();
  244.         _pool = target._pool;
  245.         _cache = target._cache;
  246.         _pool->Inc();
  247.         return *this;
  248.     }
  249.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  250.     inline MonoToStereo_base* _base() {return _cache?_cache:_method_call();}
  251.  
  252.     inline Arts::AutoSuspendState autoSuspend();
  253.     inline void start();
  254.     inline void stop();
  255.     inline void streamInit();
  256.     inline void streamStart();
  257.     inline void streamEnd();
  258.     inline float pan();
  259.     inline void pan(float _newValue);
  260. };
  261.  
  262. class ARTS_EXPORT StereoBalance_base : virtual public Arts::StereoEffect_base {
  263. public:
  264.     static unsigned long _IID; // interface ID
  265.  
  266.     static StereoBalance_base *_create(const std::string& subClass = "Arts::StereoBalance");
  267.     static StereoBalance_base *_fromString(const std::string& objectref);
  268.     static StereoBalance_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  269.  
  270.     static StereoBalance_base *_fromDynamicCast(const Arts::Object& object);
  271.     inline StereoBalance_base *_copy() {
  272.         assert(_refCnt > 0);
  273.         _refCnt++;
  274.         return this;
  275.     }
  276.  
  277.     virtual std::vector<std::string> _defaultPortsIn() const;
  278.     virtual std::vector<std::string> _defaultPortsOut() const;
  279.  
  280.     void *_cast(unsigned long iid);
  281.  
  282.     virtual float balance() = 0;
  283.     virtual void balance(float newValue) = 0;
  284. };
  285.  
  286. class ARTS_EXPORT StereoBalance_stub : virtual public StereoBalance_base, virtual public Arts::StereoEffect_stub {
  287. protected:
  288.     StereoBalance_stub();
  289.  
  290. public:
  291.     StereoBalance_stub(Arts::Connection *connection, long objectID);
  292.  
  293.     float balance();
  294.     void balance(float newValue);
  295. };
  296.  
  297. class ARTS_EXPORT StereoBalance_skel : virtual public StereoBalance_base, virtual public Arts::StereoEffect_skel {
  298. protected:
  299.     // emitters for change notifications
  300.     inline void balance_changed(float newValue) {
  301.         _emit_changed("balance_changed",newValue);
  302.     }
  303.  
  304. public:
  305.     StereoBalance_skel();
  306.  
  307.     static std::string _interfaceNameSkel();
  308.     std::string _interfaceName();
  309.     bool _isCompatibleWith(const std::string& interfacename);
  310.     void _buildMethodTable();
  311.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  312. };
  313.  
  314. }
  315. #include "reference.h"
  316. namespace Arts {
  317. class ARTS_EXPORT StereoBalance : public Arts::Object {
  318. private:
  319.     static Arts::Object_base* _Creator();
  320.     StereoBalance_base *_cache;
  321.     inline StereoBalance_base *_method_call() {
  322.         _pool->checkcreate();
  323.         if(_pool->base) {
  324.             _cache=(StereoBalance_base *)_pool->base->_cast(StereoBalance_base::_IID);
  325.             assert(_cache);
  326.         }
  327.         return _cache;
  328.     }
  329.  
  330. protected:
  331.     inline StereoBalance(StereoBalance_base* b) : Arts::Object(b), _cache(0) {}
  332.  
  333.  
  334. public:
  335.     typedef StereoBalance_base _base_class;
  336.  
  337.     inline StereoBalance() : Arts::Object(_Creator), _cache(0) {}
  338.     inline StereoBalance(const Arts::SubClass& s) :
  339.         Arts::Object(StereoBalance_base::_create(s.string())), _cache(0) {}
  340.     inline StereoBalance(const Arts::Reference &r) :
  341.         Arts::Object(r.isString()?(StereoBalance_base::_fromString(r.string())):(StereoBalance_base::_fromReference(r.reference(),true))), _cache(0) {}
  342.     inline StereoBalance(const Arts::DynamicCast& c) : Arts::Object(StereoBalance_base::_fromDynamicCast(c.object())), _cache(0) {}
  343.     inline StereoBalance(const StereoBalance& target) : Arts::Object(target._pool), _cache(target._cache) {}
  344.     inline StereoBalance(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  345.     inline static StereoBalance null() {return StereoBalance((StereoBalance_base*)0);}
  346.     inline static StereoBalance _from_base(StereoBalance_base* b) {return StereoBalance(b);}
  347.     inline StereoBalance& operator=(const StereoBalance& target) {
  348.         if (_pool == target._pool) return *this;
  349.         _pool->Dec();
  350.         _pool = target._pool;
  351.         _cache = target._cache;
  352.         _pool->Inc();
  353.         return *this;
  354.     }
  355.     inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
  356.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  357.     inline StereoBalance_base* _base() {return _cache?_cache:_method_call();}
  358.  
  359.     inline Arts::AutoSuspendState autoSuspend();
  360.     inline void start();
  361.     inline void stop();
  362.     inline void streamInit();
  363.     inline void streamStart();
  364.     inline void streamEnd();
  365.     inline float balance();
  366.     inline void balance(float _newValue);
  367. };
  368.  
  369. class ARTS_EXPORT StereoBalanceGuiFactory_base : virtual public Arts::GuiFactory_base {
  370. public:
  371.     static unsigned long _IID; // interface ID
  372.  
  373.     static StereoBalanceGuiFactory_base *_create(const std::string& subClass = "Arts::StereoBalanceGuiFactory");
  374.     static StereoBalanceGuiFactory_base *_fromString(const std::string& objectref);
  375.     static StereoBalanceGuiFactory_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  376.  
  377.     static StereoBalanceGuiFactory_base *_fromDynamicCast(const Arts::Object& object);
  378.     inline StereoBalanceGuiFactory_base *_copy() {
  379.         assert(_refCnt > 0);
  380.         _refCnt++;
  381.         return this;
  382.     }
  383.  
  384.     virtual std::vector<std::string> _defaultPortsIn() const;
  385.     virtual std::vector<std::string> _defaultPortsOut() const;
  386.  
  387.     void *_cast(unsigned long iid);
  388.  
  389. };
  390.  
  391. class ARTS_EXPORT StereoBalanceGuiFactory_stub : virtual public StereoBalanceGuiFactory_base, virtual public Arts::GuiFactory_stub {
  392. protected:
  393.     StereoBalanceGuiFactory_stub();
  394.  
  395. public:
  396.     StereoBalanceGuiFactory_stub(Arts::Connection *connection, long objectID);
  397.  
  398. };
  399.  
  400. class ARTS_EXPORT StereoBalanceGuiFactory_skel : virtual public StereoBalanceGuiFactory_base, virtual public Arts::GuiFactory_skel {
  401. public:
  402.     StereoBalanceGuiFactory_skel();
  403.  
  404.     static std::string _interfaceNameSkel();
  405.     std::string _interfaceName();
  406.     bool _isCompatibleWith(const std::string& interfacename);
  407.     void _buildMethodTable();
  408.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  409. };
  410.  
  411. }
  412. #include "reference.h"
  413. namespace Arts {
  414. class ARTS_EXPORT StereoBalanceGuiFactory : public Arts::Object {
  415. private:
  416.     static Arts::Object_base* _Creator();
  417.     StereoBalanceGuiFactory_base *_cache;
  418.     inline StereoBalanceGuiFactory_base *_method_call() {
  419.         _pool->checkcreate();
  420.         if(_pool->base) {
  421.             _cache=(StereoBalanceGuiFactory_base *)_pool->base->_cast(StereoBalanceGuiFactory_base::_IID);
  422.             assert(_cache);
  423.         }
  424.         return _cache;
  425.     }
  426.  
  427. protected:
  428.     inline StereoBalanceGuiFactory(StereoBalanceGuiFactory_base* b) : Arts::Object(b), _cache(0) {}
  429.  
  430.  
  431. public:
  432.     typedef StereoBalanceGuiFactory_base _base_class;
  433.  
  434.     inline StereoBalanceGuiFactory() : Arts::Object(_Creator), _cache(0) {}
  435.     inline StereoBalanceGuiFactory(const Arts::SubClass& s) :
  436.         Arts::Object(StereoBalanceGuiFactory_base::_create(s.string())), _cache(0) {}
  437.     inline StereoBalanceGuiFactory(const Arts::Reference &r) :
  438.         Arts::Object(r.isString()?(StereoBalanceGuiFactory_base::_fromString(r.string())):(StereoBalanceGuiFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
  439.     inline StereoBalanceGuiFactory(const Arts::DynamicCast& c) : Arts::Object(StereoBalanceGuiFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
  440.     inline StereoBalanceGuiFactory(const StereoBalanceGuiFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
  441.     inline StereoBalanceGuiFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  442.     inline static StereoBalanceGuiFactory null() {return StereoBalanceGuiFactory((StereoBalanceGuiFactory_base*)0);}
  443.     inline static StereoBalanceGuiFactory _from_base(StereoBalanceGuiFactory_base* b) {return StereoBalanceGuiFactory(b);}
  444.     inline StereoBalanceGuiFactory& operator=(const StereoBalanceGuiFactory& target) {
  445.         if (_pool == target._pool) return *this;
  446.         _pool->Dec();
  447.         _pool = target._pool;
  448.         _cache = target._cache;
  449.         _pool->Inc();
  450.         return *this;
  451.     }
  452.     inline operator Arts::GuiFactory() const { return Arts::GuiFactory(*_pool); }
  453.     inline StereoBalanceGuiFactory_base* _base() {return _cache?_cache:_method_call();}
  454.  
  455.     inline Arts::Widget createGui(Arts::Object runningObject);
  456. };
  457.  
  458. class ARTS_EXPORT FiveBandMonoComplexEQ_base : virtual public Arts::StereoEffect_base {
  459. public:
  460.     static unsigned long _IID; // interface ID
  461.  
  462.     static FiveBandMonoComplexEQ_base *_create(const std::string& subClass = "Arts::FiveBandMonoComplexEQ");
  463.     static FiveBandMonoComplexEQ_base *_fromString(const std::string& objectref);
  464.     static FiveBandMonoComplexEQ_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  465.  
  466.     static FiveBandMonoComplexEQ_base *_fromDynamicCast(const Arts::Object& object);
  467.     inline FiveBandMonoComplexEQ_base *_copy() {
  468.         assert(_refCnt > 0);
  469.         _refCnt++;
  470.         return this;
  471.     }
  472.  
  473.     virtual std::vector<std::string> _defaultPortsIn() const;
  474.     virtual std::vector<std::string> _defaultPortsOut() const;
  475.  
  476.     void *_cast(unsigned long iid);
  477.  
  478.     virtual Arts::StereoToMono s2m() = 0;
  479.     virtual float lowfreq() = 0;
  480.     virtual void lowfreq(float newValue) = 0;
  481.     virtual float lowq() = 0;
  482.     virtual void lowq(float newValue) = 0;
  483.     virtual float lowgain() = 0;
  484.     virtual void lowgain(float newValue) = 0;
  485.     virtual float mid1freq() = 0;
  486.     virtual void mid1freq(float newValue) = 0;
  487.     virtual float mid1q() = 0;
  488.     virtual void mid1q(float newValue) = 0;
  489.     virtual float mid1gain() = 0;
  490.     virtual void mid1gain(float newValue) = 0;
  491.     virtual float mid2freq() = 0;
  492.     virtual void mid2freq(float newValue) = 0;
  493.     virtual float mid2q() = 0;
  494.     virtual void mid2q(float newValue) = 0;
  495.     virtual float mid2gain() = 0;
  496.     virtual void mid2gain(float newValue) = 0;
  497.     virtual float mid3freq() = 0;
  498.     virtual void mid3freq(float newValue) = 0;
  499.     virtual float mid3q() = 0;
  500.     virtual void mid3q(float newValue) = 0;
  501.     virtual float mid3gain() = 0;
  502.     virtual void mid3gain(float newValue) = 0;
  503.     virtual float highfreq() = 0;
  504.     virtual void highfreq(float newValue) = 0;
  505.     virtual float highq() = 0;
  506.     virtual void highq(float newValue) = 0;
  507.     virtual float highgain() = 0;
  508.     virtual void highgain(float newValue) = 0;
  509.     virtual Arts::MonoToStereo m2s() = 0;
  510. };
  511.  
  512. class ARTS_EXPORT FiveBandMonoComplexEQ_stub : virtual public FiveBandMonoComplexEQ_base, virtual public Arts::StereoEffect_stub {
  513. protected:
  514.     FiveBandMonoComplexEQ_stub();
  515.  
  516. public:
  517.     FiveBandMonoComplexEQ_stub(Arts::Connection *connection, long objectID);
  518.  
  519.     Arts::StereoToMono s2m();
  520.     float lowfreq();
  521.     void lowfreq(float newValue);
  522.     float lowq();
  523.     void lowq(float newValue);
  524.     float lowgain();
  525.     void lowgain(float newValue);
  526.     float mid1freq();
  527.     void mid1freq(float newValue);
  528.     float mid1q();
  529.     void mid1q(float newValue);
  530.     float mid1gain();
  531.     void mid1gain(float newValue);
  532.     float mid2freq();
  533.     void mid2freq(float newValue);
  534.     float mid2q();
  535.     void mid2q(float newValue);
  536.     float mid2gain();
  537.     void mid2gain(float newValue);
  538.     float mid3freq();
  539.     void mid3freq(float newValue);
  540.     float mid3q();
  541.     void mid3q(float newValue);
  542.     float mid3gain();
  543.     void mid3gain(float newValue);
  544.     float highfreq();
  545.     void highfreq(float newValue);
  546.     float highq();
  547.     void highq(float newValue);
  548.     float highgain();
  549.     void highgain(float newValue);
  550.     Arts::MonoToStereo m2s();
  551. };
  552.  
  553. class ARTS_EXPORT FiveBandMonoComplexEQ_skel : virtual public FiveBandMonoComplexEQ_base, virtual public Arts::StereoEffect_skel {
  554. protected:
  555.     // emitters for change notifications
  556.     inline void lowfreq_changed(float newValue) {
  557.         _emit_changed("lowfreq_changed",newValue);
  558.     }
  559.     inline void lowq_changed(float newValue) {
  560.         _emit_changed("lowq_changed",newValue);
  561.     }
  562.     inline void lowgain_changed(float newValue) {
  563.         _emit_changed("lowgain_changed",newValue);
  564.     }
  565.     inline void mid1freq_changed(float newValue) {
  566.         _emit_changed("mid1freq_changed",newValue);
  567.     }
  568.     inline void mid1q_changed(float newValue) {
  569.         _emit_changed("mid1q_changed",newValue);
  570.     }
  571.     inline void mid1gain_changed(float newValue) {
  572.         _emit_changed("mid1gain_changed",newValue);
  573.     }
  574.     inline void mid2freq_changed(float newValue) {
  575.         _emit_changed("mid2freq_changed",newValue);
  576.     }
  577.     inline void mid2q_changed(float newValue) {
  578.         _emit_changed("mid2q_changed",newValue);
  579.     }
  580.     inline void mid2gain_changed(float newValue) {
  581.         _emit_changed("mid2gain_changed",newValue);
  582.     }
  583.     inline void mid3freq_changed(float newValue) {
  584.         _emit_changed("mid3freq_changed",newValue);
  585.     }
  586.     inline void mid3q_changed(float newValue) {
  587.         _emit_changed("mid3q_changed",newValue);
  588.     }
  589.     inline void mid3gain_changed(float newValue) {
  590.         _emit_changed("mid3gain_changed",newValue);
  591.     }
  592.     inline void highfreq_changed(float newValue) {
  593.         _emit_changed("highfreq_changed",newValue);
  594.     }
  595.     inline void highq_changed(float newValue) {
  596.         _emit_changed("highq_changed",newValue);
  597.     }
  598.     inline void highgain_changed(float newValue) {
  599.         _emit_changed("highgain_changed",newValue);
  600.     }
  601.  
  602. public:
  603.     FiveBandMonoComplexEQ_skel();
  604.  
  605.     static std::string _interfaceNameSkel();
  606.     std::string _interfaceName();
  607.     bool _isCompatibleWith(const std::string& interfacename);
  608.     void _buildMethodTable();
  609.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  610. };
  611.  
  612. }
  613. #include "reference.h"
  614. namespace Arts {
  615. class ARTS_EXPORT FiveBandMonoComplexEQ : public Arts::Object {
  616. private:
  617.     static Arts::Object_base* _Creator();
  618.     FiveBandMonoComplexEQ_base *_cache;
  619.     inline FiveBandMonoComplexEQ_base *_method_call() {
  620.         _pool->checkcreate();
  621.         if(_pool->base) {
  622.             _cache=(FiveBandMonoComplexEQ_base *)_pool->base->_cast(FiveBandMonoComplexEQ_base::_IID);
  623.             assert(_cache);
  624.         }
  625.         return _cache;
  626.     }
  627.  
  628. protected:
  629.     inline FiveBandMonoComplexEQ(FiveBandMonoComplexEQ_base* b) : Arts::Object(b), _cache(0) {}
  630.  
  631.  
  632. public:
  633.     typedef FiveBandMonoComplexEQ_base _base_class;
  634.  
  635.     inline FiveBandMonoComplexEQ() : Arts::Object(_Creator), _cache(0) {}
  636.     inline FiveBandMonoComplexEQ(const Arts::SubClass& s) :
  637.         Arts::Object(FiveBandMonoComplexEQ_base::_create(s.string())), _cache(0) {}
  638.     inline FiveBandMonoComplexEQ(const Arts::Reference &r) :
  639.         Arts::Object(r.isString()?(FiveBandMonoComplexEQ_base::_fromString(r.string())):(FiveBandMonoComplexEQ_base::_fromReference(r.reference(),true))), _cache(0) {}
  640.     inline FiveBandMonoComplexEQ(const Arts::DynamicCast& c) : Arts::Object(FiveBandMonoComplexEQ_base::_fromDynamicCast(c.object())), _cache(0) {}
  641.     inline FiveBandMonoComplexEQ(const FiveBandMonoComplexEQ& target) : Arts::Object(target._pool), _cache(target._cache) {}
  642.     inline FiveBandMonoComplexEQ(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  643.     inline static FiveBandMonoComplexEQ null() {return FiveBandMonoComplexEQ((FiveBandMonoComplexEQ_base*)0);}
  644.     inline static FiveBandMonoComplexEQ _from_base(FiveBandMonoComplexEQ_base* b) {return FiveBandMonoComplexEQ(b);}
  645.     inline FiveBandMonoComplexEQ& operator=(const FiveBandMonoComplexEQ& target) {
  646.         if (_pool == target._pool) return *this;
  647.         _pool->Dec();
  648.         _pool = target._pool;
  649.         _cache = target._cache;
  650.         _pool->Inc();
  651.         return *this;
  652.     }
  653.     inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
  654.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  655.     inline FiveBandMonoComplexEQ_base* _base() {return _cache?_cache:_method_call();}
  656.  
  657.     inline Arts::AutoSuspendState autoSuspend();
  658.     inline void start();
  659.     inline void stop();
  660.     inline void streamInit();
  661.     inline void streamStart();
  662.     inline void streamEnd();
  663.     inline Arts::StereoToMono s2m();
  664.     inline float lowfreq();
  665.     inline void lowfreq(float _newValue);
  666.     inline float lowq();
  667.     inline void lowq(float _newValue);
  668.     inline float lowgain();
  669.     inline void lowgain(float _newValue);
  670.     inline float mid1freq();
  671.     inline void mid1freq(float _newValue);
  672.     inline float mid1q();
  673.     inline void mid1q(float _newValue);
  674.     inline float mid1gain();
  675.     inline void mid1gain(float _newValue);
  676.     inline float mid2freq();
  677.     inline void mid2freq(float _newValue);
  678.     inline float mid2q();
  679.     inline void mid2q(float _newValue);
  680.     inline float mid2gain();
  681.     inline void mid2gain(float _newValue);
  682.     inline float mid3freq();
  683.     inline void mid3freq(float _newValue);
  684.     inline float mid3q();
  685.     inline void mid3q(float _newValue);
  686.     inline float mid3gain();
  687.     inline void mid3gain(float _newValue);
  688.     inline float highfreq();
  689.     inline void highfreq(float _newValue);
  690.     inline float highq();
  691.     inline void highq(float _newValue);
  692.     inline float highgain();
  693.     inline void highgain(float _newValue);
  694.     inline Arts::MonoToStereo m2s();
  695. };
  696.  
  697. class ARTS_EXPORT FiveBandMonoComplexEQGuiFactory_base : virtual public Arts::GuiFactory_base {
  698. public:
  699.     static unsigned long _IID; // interface ID
  700.  
  701.     static FiveBandMonoComplexEQGuiFactory_base *_create(const std::string& subClass = "Arts::FiveBandMonoComplexEQGuiFactory");
  702.     static FiveBandMonoComplexEQGuiFactory_base *_fromString(const std::string& objectref);
  703.     static FiveBandMonoComplexEQGuiFactory_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  704.  
  705.     static FiveBandMonoComplexEQGuiFactory_base *_fromDynamicCast(const Arts::Object& object);
  706.     inline FiveBandMonoComplexEQGuiFactory_base *_copy() {
  707.         assert(_refCnt > 0);
  708.         _refCnt++;
  709.         return this;
  710.     }
  711.  
  712.     virtual std::vector<std::string> _defaultPortsIn() const;
  713.     virtual std::vector<std::string> _defaultPortsOut() const;
  714.  
  715.     void *_cast(unsigned long iid);
  716.  
  717. };
  718.  
  719. class ARTS_EXPORT FiveBandMonoComplexEQGuiFactory_stub : virtual public FiveBandMonoComplexEQGuiFactory_base, virtual public Arts::GuiFactory_stub {
  720. protected:
  721.     FiveBandMonoComplexEQGuiFactory_stub();
  722.  
  723. public:
  724.     FiveBandMonoComplexEQGuiFactory_stub(Arts::Connection *connection, long objectID);
  725.  
  726. };
  727.  
  728. class ARTS_EXPORT FiveBandMonoComplexEQGuiFactory_skel : virtual public FiveBandMonoComplexEQGuiFactory_base, virtual public Arts::GuiFactory_skel {
  729. public:
  730.     FiveBandMonoComplexEQGuiFactory_skel();
  731.  
  732.     static std::string _interfaceNameSkel();
  733.     std::string _interfaceName();
  734.     bool _isCompatibleWith(const std::string& interfacename);
  735.     void _buildMethodTable();
  736.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  737. };
  738.  
  739. }
  740. #include "reference.h"
  741. namespace Arts {
  742. class ARTS_EXPORT FiveBandMonoComplexEQGuiFactory : public Arts::Object {
  743. private:
  744.     static Arts::Object_base* _Creator();
  745.     FiveBandMonoComplexEQGuiFactory_base *_cache;
  746.     inline FiveBandMonoComplexEQGuiFactory_base *_method_call() {
  747.         _pool->checkcreate();
  748.         if(_pool->base) {
  749.             _cache=(FiveBandMonoComplexEQGuiFactory_base *)_pool->base->_cast(FiveBandMonoComplexEQGuiFactory_base::_IID);
  750.             assert(_cache);
  751.         }
  752.         return _cache;
  753.     }
  754.  
  755. protected:
  756.     inline FiveBandMonoComplexEQGuiFactory(FiveBandMonoComplexEQGuiFactory_base* b) : Arts::Object(b), _cache(0) {}
  757.  
  758.  
  759. public:
  760.     typedef FiveBandMonoComplexEQGuiFactory_base _base_class;
  761.  
  762.     inline FiveBandMonoComplexEQGuiFactory() : Arts::Object(_Creator), _cache(0) {}
  763.     inline FiveBandMonoComplexEQGuiFactory(const Arts::SubClass& s) :
  764.         Arts::Object(FiveBandMonoComplexEQGuiFactory_base::_create(s.string())), _cache(0) {}
  765.     inline FiveBandMonoComplexEQGuiFactory(const Arts::Reference &r) :
  766.         Arts::Object(r.isString()?(FiveBandMonoComplexEQGuiFactory_base::_fromString(r.string())):(FiveBandMonoComplexEQGuiFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
  767.     inline FiveBandMonoComplexEQGuiFactory(const Arts::DynamicCast& c) : Arts::Object(FiveBandMonoComplexEQGuiFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
  768.     inline FiveBandMonoComplexEQGuiFactory(const FiveBandMonoComplexEQGuiFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
  769.     inline FiveBandMonoComplexEQGuiFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  770.     inline static FiveBandMonoComplexEQGuiFactory null() {return FiveBandMonoComplexEQGuiFactory((FiveBandMonoComplexEQGuiFactory_base*)0);}
  771.     inline static FiveBandMonoComplexEQGuiFactory _from_base(FiveBandMonoComplexEQGuiFactory_base* b) {return FiveBandMonoComplexEQGuiFactory(b);}
  772.     inline FiveBandMonoComplexEQGuiFactory& operator=(const FiveBandMonoComplexEQGuiFactory& target) {
  773.         if (_pool == target._pool) return *this;
  774.         _pool->Dec();
  775.         _pool = target._pool;
  776.         _cache = target._cache;
  777.         _pool->Inc();
  778.         return *this;
  779.     }
  780.     inline operator Arts::GuiFactory() const { return Arts::GuiFactory(*_pool); }
  781.     inline FiveBandMonoComplexEQGuiFactory_base* _base() {return _cache?_cache:_method_call();}
  782.  
  783.     inline Arts::Widget createGui(Arts::Object runningObject);
  784. };
  785.  
  786. class ARTS_EXPORT Synth_VOICE_REMOVAL_base : virtual public Arts::StereoEffect_base {
  787. public:
  788.     static unsigned long _IID; // interface ID
  789.  
  790.     static Synth_VOICE_REMOVAL_base *_create(const std::string& subClass = "Arts::Synth_VOICE_REMOVAL");
  791.     static Synth_VOICE_REMOVAL_base *_fromString(const std::string& objectref);
  792.     static Synth_VOICE_REMOVAL_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  793.  
  794.     static Synth_VOICE_REMOVAL_base *_fromDynamicCast(const Arts::Object& object);
  795.     inline Synth_VOICE_REMOVAL_base *_copy() {
  796.         assert(_refCnt > 0);
  797.         _refCnt++;
  798.         return this;
  799.     }
  800.  
  801.     virtual std::vector<std::string> _defaultPortsIn() const;
  802.     virtual std::vector<std::string> _defaultPortsOut() const;
  803.  
  804.     void *_cast(unsigned long iid);
  805.  
  806.     virtual float position() = 0;
  807.     virtual void position(float newValue) = 0;
  808.     virtual float frequency() = 0;
  809.     virtual void frequency(float newValue) = 0;
  810. };
  811.  
  812. class ARTS_EXPORT Synth_VOICE_REMOVAL_stub : virtual public Synth_VOICE_REMOVAL_base, virtual public Arts::StereoEffect_stub {
  813. protected:
  814.     Synth_VOICE_REMOVAL_stub();
  815.  
  816. public:
  817.     Synth_VOICE_REMOVAL_stub(Arts::Connection *connection, long objectID);
  818.  
  819.     float position();
  820.     void position(float newValue);
  821.     float frequency();
  822.     void frequency(float newValue);
  823. };
  824.  
  825. class ARTS_EXPORT Synth_VOICE_REMOVAL_skel : virtual public Synth_VOICE_REMOVAL_base, virtual public Arts::StereoEffect_skel {
  826. protected:
  827.     // emitters for change notifications
  828.     inline void position_changed(float newValue) {
  829.         _emit_changed("position_changed",newValue);
  830.     }
  831.     inline void frequency_changed(float newValue) {
  832.         _emit_changed("frequency_changed",newValue);
  833.     }
  834.  
  835. public:
  836.     Synth_VOICE_REMOVAL_skel();
  837.  
  838.     static std::string _interfaceNameSkel();
  839.     std::string _interfaceName();
  840.     bool _isCompatibleWith(const std::string& interfacename);
  841.     void _buildMethodTable();
  842.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  843. };
  844.  
  845. }
  846. #include "reference.h"
  847. namespace Arts {
  848. class ARTS_EXPORT Synth_VOICE_REMOVAL : public Arts::Object {
  849. private:
  850.     static Arts::Object_base* _Creator();
  851.     Synth_VOICE_REMOVAL_base *_cache;
  852.     inline Synth_VOICE_REMOVAL_base *_method_call() {
  853.         _pool->checkcreate();
  854.         if(_pool->base) {
  855.             _cache=(Synth_VOICE_REMOVAL_base *)_pool->base->_cast(Synth_VOICE_REMOVAL_base::_IID);
  856.             assert(_cache);
  857.         }
  858.         return _cache;
  859.     }
  860.  
  861. protected:
  862.     inline Synth_VOICE_REMOVAL(Synth_VOICE_REMOVAL_base* b) : Arts::Object(b), _cache(0) {}
  863.  
  864.  
  865. public:
  866.     typedef Synth_VOICE_REMOVAL_base _base_class;
  867.  
  868.     inline Synth_VOICE_REMOVAL() : Arts::Object(_Creator), _cache(0) {}
  869.     inline Synth_VOICE_REMOVAL(const Arts::SubClass& s) :
  870.         Arts::Object(Synth_VOICE_REMOVAL_base::_create(s.string())), _cache(0) {}
  871.     inline Synth_VOICE_REMOVAL(const Arts::Reference &r) :
  872.         Arts::Object(r.isString()?(Synth_VOICE_REMOVAL_base::_fromString(r.string())):(Synth_VOICE_REMOVAL_base::_fromReference(r.reference(),true))), _cache(0) {}
  873.     inline Synth_VOICE_REMOVAL(const Arts::DynamicCast& c) : Arts::Object(Synth_VOICE_REMOVAL_base::_fromDynamicCast(c.object())), _cache(0) {}
  874.     inline Synth_VOICE_REMOVAL(const Synth_VOICE_REMOVAL& target) : Arts::Object(target._pool), _cache(target._cache) {}
  875.     inline Synth_VOICE_REMOVAL(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  876.     inline static Synth_VOICE_REMOVAL null() {return Synth_VOICE_REMOVAL((Synth_VOICE_REMOVAL_base*)0);}
  877.     inline static Synth_VOICE_REMOVAL _from_base(Synth_VOICE_REMOVAL_base* b) {return Synth_VOICE_REMOVAL(b);}
  878.     inline Synth_VOICE_REMOVAL& operator=(const Synth_VOICE_REMOVAL& target) {
  879.         if (_pool == target._pool) return *this;
  880.         _pool->Dec();
  881.         _pool = target._pool;
  882.         _cache = target._cache;
  883.         _pool->Inc();
  884.         return *this;
  885.     }
  886.     inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
  887.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  888.     inline Synth_VOICE_REMOVAL_base* _base() {return _cache?_cache:_method_call();}
  889.  
  890.     inline Arts::AutoSuspendState autoSuspend();
  891.     inline void start();
  892.     inline void stop();
  893.     inline void streamInit();
  894.     inline void streamStart();
  895.     inline void streamEnd();
  896.     inline float position();
  897.     inline void position(float _newValue);
  898.     inline float frequency();
  899.     inline void frequency(float _newValue);
  900. };
  901.  
  902. class ARTS_EXPORT VoiceRemovalGuiFactory_base : virtual public Arts::GuiFactory_base {
  903. public:
  904.     static unsigned long _IID; // interface ID
  905.  
  906.     static VoiceRemovalGuiFactory_base *_create(const std::string& subClass = "Arts::VoiceRemovalGuiFactory");
  907.     static VoiceRemovalGuiFactory_base *_fromString(const std::string& objectref);
  908.     static VoiceRemovalGuiFactory_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  909.  
  910.     static VoiceRemovalGuiFactory_base *_fromDynamicCast(const Arts::Object& object);
  911.     inline VoiceRemovalGuiFactory_base *_copy() {
  912.         assert(_refCnt > 0);
  913.         _refCnt++;
  914.         return this;
  915.     }
  916.  
  917.     virtual std::vector<std::string> _defaultPortsIn() const;
  918.     virtual std::vector<std::string> _defaultPortsOut() const;
  919.  
  920.     void *_cast(unsigned long iid);
  921.  
  922. };
  923.  
  924. class ARTS_EXPORT VoiceRemovalGuiFactory_stub : virtual public VoiceRemovalGuiFactory_base, virtual public Arts::GuiFactory_stub {
  925. protected:
  926.     VoiceRemovalGuiFactory_stub();
  927.  
  928. public:
  929.     VoiceRemovalGuiFactory_stub(Arts::Connection *connection, long objectID);
  930.  
  931. };
  932.  
  933. class ARTS_EXPORT VoiceRemovalGuiFactory_skel : virtual public VoiceRemovalGuiFactory_base, virtual public Arts::GuiFactory_skel {
  934. public:
  935.     VoiceRemovalGuiFactory_skel();
  936.  
  937.     static std::string _interfaceNameSkel();
  938.     std::string _interfaceName();
  939.     bool _isCompatibleWith(const std::string& interfacename);
  940.     void _buildMethodTable();
  941.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  942. };
  943.  
  944. }
  945. #include "reference.h"
  946. namespace Arts {
  947. class ARTS_EXPORT VoiceRemovalGuiFactory : public Arts::Object {
  948. private:
  949.     static Arts::Object_base* _Creator();
  950.     VoiceRemovalGuiFactory_base *_cache;
  951.     inline VoiceRemovalGuiFactory_base *_method_call() {
  952.         _pool->checkcreate();
  953.         if(_pool->base) {
  954.             _cache=(VoiceRemovalGuiFactory_base *)_pool->base->_cast(VoiceRemovalGuiFactory_base::_IID);
  955.             assert(_cache);
  956.         }
  957.         return _cache;
  958.     }
  959.  
  960. protected:
  961.     inline VoiceRemovalGuiFactory(VoiceRemovalGuiFactory_base* b) : Arts::Object(b), _cache(0) {}
  962.  
  963.  
  964. public:
  965.     typedef VoiceRemovalGuiFactory_base _base_class;
  966.  
  967.     inline VoiceRemovalGuiFactory() : Arts::Object(_Creator), _cache(0) {}
  968.     inline VoiceRemovalGuiFactory(const Arts::SubClass& s) :
  969.         Arts::Object(VoiceRemovalGuiFactory_base::_create(s.string())), _cache(0) {}
  970.     inline VoiceRemovalGuiFactory(const Arts::Reference &r) :
  971.         Arts::Object(r.isString()?(VoiceRemovalGuiFactory_base::_fromString(r.string())):(VoiceRemovalGuiFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
  972.     inline VoiceRemovalGuiFactory(const Arts::DynamicCast& c) : Arts::Object(VoiceRemovalGuiFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
  973.     inline VoiceRemovalGuiFactory(const VoiceRemovalGuiFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
  974.     inline VoiceRemovalGuiFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  975.     inline static VoiceRemovalGuiFactory null() {return VoiceRemovalGuiFactory((VoiceRemovalGuiFactory_base*)0);}
  976.     inline static VoiceRemovalGuiFactory _from_base(VoiceRemovalGuiFactory_base* b) {return VoiceRemovalGuiFactory(b);}
  977.     inline VoiceRemovalGuiFactory& operator=(const VoiceRemovalGuiFactory& target) {
  978.         if (_pool == target._pool) return *this;
  979.         _pool->Dec();
  980.         _pool = target._pool;
  981.         _cache = target._cache;
  982.         _pool->Inc();
  983.         return *this;
  984.     }
  985.     inline operator Arts::GuiFactory() const { return Arts::GuiFactory(*_pool); }
  986.     inline VoiceRemovalGuiFactory_base* _base() {return _cache?_cache:_method_call();}
  987.  
  988.     inline Arts::Widget createGui(Arts::Object runningObject);
  989. };
  990.  
  991. class ARTS_EXPORT Synth_STEREO_COMPRESSOR_base : virtual public Arts::StereoEffect_base {
  992. public:
  993.     static unsigned long _IID; // interface ID
  994.  
  995.     static Synth_STEREO_COMPRESSOR_base *_create(const std::string& subClass = "Arts::Synth_STEREO_COMPRESSOR");
  996.     static Synth_STEREO_COMPRESSOR_base *_fromString(const std::string& objectref);
  997.     static Synth_STEREO_COMPRESSOR_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  998.  
  999.     static Synth_STEREO_COMPRESSOR_base *_fromDynamicCast(const Arts::Object& object);
  1000.     inline Synth_STEREO_COMPRESSOR_base *_copy() {
  1001.         assert(_refCnt > 0);
  1002.         _refCnt++;
  1003.         return this;
  1004.     }
  1005.  
  1006.     virtual std::vector<std::string> _defaultPortsIn() const;
  1007.     virtual std::vector<std::string> _defaultPortsOut() const;
  1008.  
  1009.     void *_cast(unsigned long iid);
  1010.  
  1011.     virtual float attack() = 0;
  1012.     virtual void attack(float newValue) = 0;
  1013.     virtual float release() = 0;
  1014.     virtual void release(float newValue) = 0;
  1015.     virtual float threshold() = 0;
  1016.     virtual void threshold(float newValue) = 0;
  1017.     virtual float ratio() = 0;
  1018.     virtual void ratio(float newValue) = 0;
  1019.     virtual float output() = 0;
  1020.     virtual void output(float newValue) = 0;
  1021.     virtual bool thru() = 0;
  1022.     virtual void thru(bool newValue) = 0;
  1023. };
  1024.  
  1025. class ARTS_EXPORT Synth_STEREO_COMPRESSOR_stub : virtual public Synth_STEREO_COMPRESSOR_base, virtual public Arts::StereoEffect_stub {
  1026. protected:
  1027.     Synth_STEREO_COMPRESSOR_stub();
  1028.  
  1029. public:
  1030.     Synth_STEREO_COMPRESSOR_stub(Arts::Connection *connection, long objectID);
  1031.  
  1032.     float attack();
  1033.     void attack(float newValue);
  1034.     float release();
  1035.     void release(float newValue);
  1036.     float threshold();
  1037.     void threshold(float newValue);
  1038.     float ratio();
  1039.     void ratio(float newValue);
  1040.     float output();
  1041.     void output(float newValue);
  1042.     bool thru();
  1043.     void thru(bool newValue);
  1044. };
  1045.  
  1046. class ARTS_EXPORT Synth_STEREO_COMPRESSOR_skel : virtual public Synth_STEREO_COMPRESSOR_base, virtual public Arts::StereoEffect_skel {
  1047. protected:
  1048.     // emitters for change notifications
  1049.     inline void attack_changed(float newValue) {
  1050.         _emit_changed("attack_changed",newValue);
  1051.     }
  1052.     inline void release_changed(float newValue) {
  1053.         _emit_changed("release_changed",newValue);
  1054.     }
  1055.     inline void threshold_changed(float newValue) {
  1056.         _emit_changed("threshold_changed",newValue);
  1057.     }
  1058.     inline void ratio_changed(float newValue) {
  1059.         _emit_changed("ratio_changed",newValue);
  1060.     }
  1061.     inline void output_changed(float newValue) {
  1062.         _emit_changed("output_changed",newValue);
  1063.     }
  1064.     inline void thru_changed(bool newValue) {
  1065.         _emit_changed("thru_changed",newValue);
  1066.     }
  1067.  
  1068. public:
  1069.     Synth_STEREO_COMPRESSOR_skel();
  1070.  
  1071.     static std::string _interfaceNameSkel();
  1072.     std::string _interfaceName();
  1073.     bool _isCompatibleWith(const std::string& interfacename);
  1074.     void _buildMethodTable();
  1075.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1076. };
  1077.  
  1078. }
  1079. #include "reference.h"
  1080. namespace Arts {
  1081. class ARTS_EXPORT Synth_STEREO_COMPRESSOR : public Arts::Object {
  1082. private:
  1083.     static Arts::Object_base* _Creator();
  1084.     Synth_STEREO_COMPRESSOR_base *_cache;
  1085.     inline Synth_STEREO_COMPRESSOR_base *_method_call() {
  1086.         _pool->checkcreate();
  1087.         if(_pool->base) {
  1088.             _cache=(Synth_STEREO_COMPRESSOR_base *)_pool->base->_cast(Synth_STEREO_COMPRESSOR_base::_IID);
  1089.             assert(_cache);
  1090.         }
  1091.         return _cache;
  1092.     }
  1093.  
  1094. protected:
  1095.     inline Synth_STEREO_COMPRESSOR(Synth_STEREO_COMPRESSOR_base* b) : Arts::Object(b), _cache(0) {}
  1096.  
  1097.  
  1098. public:
  1099.     typedef Synth_STEREO_COMPRESSOR_base _base_class;
  1100.  
  1101.     inline Synth_STEREO_COMPRESSOR() : Arts::Object(_Creator), _cache(0) {}
  1102.     inline Synth_STEREO_COMPRESSOR(const Arts::SubClass& s) :
  1103.         Arts::Object(Synth_STEREO_COMPRESSOR_base::_create(s.string())), _cache(0) {}
  1104.     inline Synth_STEREO_COMPRESSOR(const Arts::Reference &r) :
  1105.         Arts::Object(r.isString()?(Synth_STEREO_COMPRESSOR_base::_fromString(r.string())):(Synth_STEREO_COMPRESSOR_base::_fromReference(r.reference(),true))), _cache(0) {}
  1106.     inline Synth_STEREO_COMPRESSOR(const Arts::DynamicCast& c) : Arts::Object(Synth_STEREO_COMPRESSOR_base::_fromDynamicCast(c.object())), _cache(0) {}
  1107.     inline Synth_STEREO_COMPRESSOR(const Synth_STEREO_COMPRESSOR& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1108.     inline Synth_STEREO_COMPRESSOR(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1109.     inline static Synth_STEREO_COMPRESSOR null() {return Synth_STEREO_COMPRESSOR((Synth_STEREO_COMPRESSOR_base*)0);}
  1110.     inline static Synth_STEREO_COMPRESSOR _from_base(Synth_STEREO_COMPRESSOR_base* b) {return Synth_STEREO_COMPRESSOR(b);}
  1111.     inline Synth_STEREO_COMPRESSOR& operator=(const Synth_STEREO_COMPRESSOR& target) {
  1112.         if (_pool == target._pool) return *this;
  1113.         _pool->Dec();
  1114.         _pool = target._pool;
  1115.         _cache = target._cache;
  1116.         _pool->Inc();
  1117.         return *this;
  1118.     }
  1119.     inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
  1120.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  1121.     inline Synth_STEREO_COMPRESSOR_base* _base() {return _cache?_cache:_method_call();}
  1122.  
  1123.     inline Arts::AutoSuspendState autoSuspend();
  1124.     inline void start();
  1125.     inline void stop();
  1126.     inline void streamInit();
  1127.     inline void streamStart();
  1128.     inline void streamEnd();
  1129.     inline float attack();
  1130.     inline void attack(float _newValue);
  1131.     inline float release();
  1132.     inline void release(float _newValue);
  1133.     inline float threshold();
  1134.     inline void threshold(float _newValue);
  1135.     inline float ratio();
  1136.     inline void ratio(float _newValue);
  1137.     inline float output();
  1138.     inline void output(float _newValue);
  1139.     inline bool thru();
  1140.     inline void thru(bool _newValue);
  1141. };
  1142.  
  1143. class ARTS_EXPORT StereoCompressorGuiFactory_base : virtual public Arts::GuiFactory_base {
  1144. public:
  1145.     static unsigned long _IID; // interface ID
  1146.  
  1147.     static StereoCompressorGuiFactory_base *_create(const std::string& subClass = "Arts::StereoCompressorGuiFactory");
  1148.     static StereoCompressorGuiFactory_base *_fromString(const std::string& objectref);
  1149.     static StereoCompressorGuiFactory_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1150.  
  1151.     static StereoCompressorGuiFactory_base *_fromDynamicCast(const Arts::Object& object);
  1152.     inline StereoCompressorGuiFactory_base *_copy() {
  1153.         assert(_refCnt > 0);
  1154.         _refCnt++;
  1155.         return this;
  1156.     }
  1157.  
  1158.     virtual std::vector<std::string> _defaultPortsIn() const;
  1159.     virtual std::vector<std::string> _defaultPortsOut() const;
  1160.  
  1161.     void *_cast(unsigned long iid);
  1162.  
  1163. };
  1164.  
  1165. class ARTS_EXPORT StereoCompressorGuiFactory_stub : virtual public StereoCompressorGuiFactory_base, virtual public Arts::GuiFactory_stub {
  1166. protected:
  1167.     StereoCompressorGuiFactory_stub();
  1168.  
  1169. public:
  1170.     StereoCompressorGuiFactory_stub(Arts::Connection *connection, long objectID);
  1171.  
  1172. };
  1173.  
  1174. class ARTS_EXPORT StereoCompressorGuiFactory_skel : virtual public StereoCompressorGuiFactory_base, virtual public Arts::GuiFactory_skel {
  1175. public:
  1176.     StereoCompressorGuiFactory_skel();
  1177.  
  1178.     static std::string _interfaceNameSkel();
  1179.     std::string _interfaceName();
  1180.     bool _isCompatibleWith(const std::string& interfacename);
  1181.     void _buildMethodTable();
  1182.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1183. };
  1184.  
  1185. }
  1186. #include "reference.h"
  1187. namespace Arts {
  1188. class ARTS_EXPORT StereoCompressorGuiFactory : public Arts::Object {
  1189. private:
  1190.     static Arts::Object_base* _Creator();
  1191.     StereoCompressorGuiFactory_base *_cache;
  1192.     inline StereoCompressorGuiFactory_base *_method_call() {
  1193.         _pool->checkcreate();
  1194.         if(_pool->base) {
  1195.             _cache=(StereoCompressorGuiFactory_base *)_pool->base->_cast(StereoCompressorGuiFactory_base::_IID);
  1196.             assert(_cache);
  1197.         }
  1198.         return _cache;
  1199.     }
  1200.  
  1201. protected:
  1202.     inline StereoCompressorGuiFactory(StereoCompressorGuiFactory_base* b) : Arts::Object(b), _cache(0) {}
  1203.  
  1204.  
  1205. public:
  1206.     typedef StereoCompressorGuiFactory_base _base_class;
  1207.  
  1208.     inline StereoCompressorGuiFactory() : Arts::Object(_Creator), _cache(0) {}
  1209.     inline StereoCompressorGuiFactory(const Arts::SubClass& s) :
  1210.         Arts::Object(StereoCompressorGuiFactory_base::_create(s.string())), _cache(0) {}
  1211.     inline StereoCompressorGuiFactory(const Arts::Reference &r) :
  1212.         Arts::Object(r.isString()?(StereoCompressorGuiFactory_base::_fromString(r.string())):(StereoCompressorGuiFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
  1213.     inline StereoCompressorGuiFactory(const Arts::DynamicCast& c) : Arts::Object(StereoCompressorGuiFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
  1214.     inline StereoCompressorGuiFactory(const StereoCompressorGuiFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1215.     inline StereoCompressorGuiFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1216.     inline static StereoCompressorGuiFactory null() {return StereoCompressorGuiFactory((StereoCompressorGuiFactory_base*)0);}
  1217.     inline static StereoCompressorGuiFactory _from_base(StereoCompressorGuiFactory_base* b) {return StereoCompressorGuiFactory(b);}
  1218.     inline StereoCompressorGuiFactory& operator=(const StereoCompressorGuiFactory& target) {
  1219.         if (_pool == target._pool) return *this;
  1220.         _pool->Dec();
  1221.         _pool = target._pool;
  1222.         _cache = target._cache;
  1223.         _pool->Inc();
  1224.         return *this;
  1225.     }
  1226.     inline operator Arts::GuiFactory() const { return Arts::GuiFactory(*_pool); }
  1227.     inline StereoCompressorGuiFactory_base* _base() {return _cache?_cache:_method_call();}
  1228.  
  1229.     inline Arts::Widget createGui(Arts::Object runningObject);
  1230. };
  1231.  
  1232. class ARTS_EXPORT Synth_STEREO_PITCH_SHIFT_base : virtual public Arts::StereoEffect_base {
  1233. public:
  1234.     static unsigned long _IID; // interface ID
  1235.  
  1236.     static Synth_STEREO_PITCH_SHIFT_base *_create(const std::string& subClass = "Arts::Synth_STEREO_PITCH_SHIFT");
  1237.     static Synth_STEREO_PITCH_SHIFT_base *_fromString(const std::string& objectref);
  1238.     static Synth_STEREO_PITCH_SHIFT_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1239.  
  1240.     static Synth_STEREO_PITCH_SHIFT_base *_fromDynamicCast(const Arts::Object& object);
  1241.     inline Synth_STEREO_PITCH_SHIFT_base *_copy() {
  1242.         assert(_refCnt > 0);
  1243.         _refCnt++;
  1244.         return this;
  1245.     }
  1246.  
  1247.     virtual std::vector<std::string> _defaultPortsIn() const;
  1248.     virtual std::vector<std::string> _defaultPortsOut() const;
  1249.  
  1250.     void *_cast(unsigned long iid);
  1251.  
  1252.     virtual float speed() = 0;
  1253.     virtual void speed(float newValue) = 0;
  1254.     virtual float frequency() = 0;
  1255.     virtual void frequency(float newValue) = 0;
  1256. };
  1257.  
  1258. class ARTS_EXPORT Synth_STEREO_PITCH_SHIFT_stub : virtual public Synth_STEREO_PITCH_SHIFT_base, virtual public Arts::StereoEffect_stub {
  1259. protected:
  1260.     Synth_STEREO_PITCH_SHIFT_stub();
  1261.  
  1262. public:
  1263.     Synth_STEREO_PITCH_SHIFT_stub(Arts::Connection *connection, long objectID);
  1264.  
  1265.     float speed();
  1266.     void speed(float newValue);
  1267.     float frequency();
  1268.     void frequency(float newValue);
  1269. };
  1270.  
  1271. class ARTS_EXPORT Synth_STEREO_PITCH_SHIFT_skel : virtual public Synth_STEREO_PITCH_SHIFT_base, virtual public Arts::StereoEffect_skel {
  1272. protected:
  1273.     // emitters for change notifications
  1274.     inline void speed_changed(float newValue) {
  1275.         _emit_changed("speed_changed",newValue);
  1276.     }
  1277.     inline void frequency_changed(float newValue) {
  1278.         _emit_changed("frequency_changed",newValue);
  1279.     }
  1280.  
  1281. public:
  1282.     Synth_STEREO_PITCH_SHIFT_skel();
  1283.  
  1284.     static std::string _interfaceNameSkel();
  1285.     std::string _interfaceName();
  1286.     bool _isCompatibleWith(const std::string& interfacename);
  1287.     void _buildMethodTable();
  1288.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1289. };
  1290.  
  1291. }
  1292. #include "reference.h"
  1293. namespace Arts {
  1294. class ARTS_EXPORT Synth_STEREO_PITCH_SHIFT : public Arts::Object {
  1295. private:
  1296.     static Arts::Object_base* _Creator();
  1297.     Synth_STEREO_PITCH_SHIFT_base *_cache;
  1298.     inline Synth_STEREO_PITCH_SHIFT_base *_method_call() {
  1299.         _pool->checkcreate();
  1300.         if(_pool->base) {
  1301.             _cache=(Synth_STEREO_PITCH_SHIFT_base *)_pool->base->_cast(Synth_STEREO_PITCH_SHIFT_base::_IID);
  1302.             assert(_cache);
  1303.         }
  1304.         return _cache;
  1305.     }
  1306.  
  1307. protected:
  1308.     inline Synth_STEREO_PITCH_SHIFT(Synth_STEREO_PITCH_SHIFT_base* b) : Arts::Object(b), _cache(0) {}
  1309.  
  1310.  
  1311. public:
  1312.     typedef Synth_STEREO_PITCH_SHIFT_base _base_class;
  1313.  
  1314.     inline Synth_STEREO_PITCH_SHIFT() : Arts::Object(_Creator), _cache(0) {}
  1315.     inline Synth_STEREO_PITCH_SHIFT(const Arts::SubClass& s) :
  1316.         Arts::Object(Synth_STEREO_PITCH_SHIFT_base::_create(s.string())), _cache(0) {}
  1317.     inline Synth_STEREO_PITCH_SHIFT(const Arts::Reference &r) :
  1318.         Arts::Object(r.isString()?(Synth_STEREO_PITCH_SHIFT_base::_fromString(r.string())):(Synth_STEREO_PITCH_SHIFT_base::_fromReference(r.reference(),true))), _cache(0) {}
  1319.     inline Synth_STEREO_PITCH_SHIFT(const Arts::DynamicCast& c) : Arts::Object(Synth_STEREO_PITCH_SHIFT_base::_fromDynamicCast(c.object())), _cache(0) {}
  1320.     inline Synth_STEREO_PITCH_SHIFT(const Synth_STEREO_PITCH_SHIFT& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1321.     inline Synth_STEREO_PITCH_SHIFT(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1322.     inline static Synth_STEREO_PITCH_SHIFT null() {return Synth_STEREO_PITCH_SHIFT((Synth_STEREO_PITCH_SHIFT_base*)0);}
  1323.     inline static Synth_STEREO_PITCH_SHIFT _from_base(Synth_STEREO_PITCH_SHIFT_base* b) {return Synth_STEREO_PITCH_SHIFT(b);}
  1324.     inline Synth_STEREO_PITCH_SHIFT& operator=(const Synth_STEREO_PITCH_SHIFT& target) {
  1325.         if (_pool == target._pool) return *this;
  1326.         _pool->Dec();
  1327.         _pool = target._pool;
  1328.         _cache = target._cache;
  1329.         _pool->Inc();
  1330.         return *this;
  1331.     }
  1332.     inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
  1333.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  1334.     inline Synth_STEREO_PITCH_SHIFT_base* _base() {return _cache?_cache:_method_call();}
  1335.  
  1336.     inline Arts::AutoSuspendState autoSuspend();
  1337.     inline void start();
  1338.     inline void stop();
  1339.     inline void streamInit();
  1340.     inline void streamStart();
  1341.     inline void streamEnd();
  1342.     inline float speed();
  1343.     inline void speed(float _newValue);
  1344.     inline float frequency();
  1345.     inline void frequency(float _newValue);
  1346. };
  1347.  
  1348. class ARTS_EXPORT Synth_STEREO_PITCH_SHIFT_FFT_base : virtual public Arts::StereoEffect_base {
  1349. public:
  1350.     static unsigned long _IID; // interface ID
  1351.  
  1352.     static Synth_STEREO_PITCH_SHIFT_FFT_base *_create(const std::string& subClass = "Arts::Synth_STEREO_PITCH_SHIFT_FFT");
  1353.     static Synth_STEREO_PITCH_SHIFT_FFT_base *_fromString(const std::string& objectref);
  1354.     static Synth_STEREO_PITCH_SHIFT_FFT_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1355.  
  1356.     static Synth_STEREO_PITCH_SHIFT_FFT_base *_fromDynamicCast(const Arts::Object& object);
  1357.     inline Synth_STEREO_PITCH_SHIFT_FFT_base *_copy() {
  1358.         assert(_refCnt > 0);
  1359.         _refCnt++;
  1360.         return this;
  1361.     }
  1362.  
  1363.     virtual std::vector<std::string> _defaultPortsIn() const;
  1364.     virtual std::vector<std::string> _defaultPortsOut() const;
  1365.  
  1366.     void *_cast(unsigned long iid);
  1367.  
  1368.     virtual float speed() = 0;
  1369.     virtual void speed(float newValue) = 0;
  1370.     virtual float scaleFactor() = 0;
  1371.     virtual void scaleFactor(float newValue) = 0;
  1372.     virtual long frameSize() = 0;
  1373.     virtual void frameSize(long newValue) = 0;
  1374.     virtual long oversample() = 0;
  1375.     virtual void oversample(long newValue) = 0;
  1376. };
  1377.  
  1378. class ARTS_EXPORT Synth_STEREO_PITCH_SHIFT_FFT_stub : virtual public Synth_STEREO_PITCH_SHIFT_FFT_base, virtual public Arts::StereoEffect_stub {
  1379. protected:
  1380.     Synth_STEREO_PITCH_SHIFT_FFT_stub();
  1381.  
  1382. public:
  1383.     Synth_STEREO_PITCH_SHIFT_FFT_stub(Arts::Connection *connection, long objectID);
  1384.  
  1385.     float speed();
  1386.     void speed(float newValue);
  1387.     float scaleFactor();
  1388.     void scaleFactor(float newValue);
  1389.     long frameSize();
  1390.     void frameSize(long newValue);
  1391.     long oversample();
  1392.     void oversample(long newValue);
  1393. };
  1394.  
  1395. class ARTS_EXPORT Synth_STEREO_PITCH_SHIFT_FFT_skel : virtual public Synth_STEREO_PITCH_SHIFT_FFT_base, virtual public Arts::StereoEffect_skel {
  1396. protected:
  1397.     // emitters for change notifications
  1398.     inline void speed_changed(float newValue) {
  1399.         _emit_changed("speed_changed",newValue);
  1400.     }
  1401.     inline void scaleFactor_changed(float newValue) {
  1402.         _emit_changed("scaleFactor_changed",newValue);
  1403.     }
  1404.     inline void frameSize_changed(long newValue) {
  1405.         _emit_changed("frameSize_changed",newValue);
  1406.     }
  1407.     inline void oversample_changed(long newValue) {
  1408.         _emit_changed("oversample_changed",newValue);
  1409.     }
  1410.  
  1411. public:
  1412.     Synth_STEREO_PITCH_SHIFT_FFT_skel();
  1413.  
  1414.     static std::string _interfaceNameSkel();
  1415.     std::string _interfaceName();
  1416.     bool _isCompatibleWith(const std::string& interfacename);
  1417.     void _buildMethodTable();
  1418.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1419. };
  1420.  
  1421. }
  1422. #include "reference.h"
  1423. namespace Arts {
  1424. class ARTS_EXPORT Synth_STEREO_PITCH_SHIFT_FFT : public Arts::Object {
  1425. private:
  1426.     static Arts::Object_base* _Creator();
  1427.     Synth_STEREO_PITCH_SHIFT_FFT_base *_cache;
  1428.     inline Synth_STEREO_PITCH_SHIFT_FFT_base *_method_call() {
  1429.         _pool->checkcreate();
  1430.         if(_pool->base) {
  1431.             _cache=(Synth_STEREO_PITCH_SHIFT_FFT_base *)_pool->base->_cast(Synth_STEREO_PITCH_SHIFT_FFT_base::_IID);
  1432.             assert(_cache);
  1433.         }
  1434.         return _cache;
  1435.     }
  1436.  
  1437. protected:
  1438.     inline Synth_STEREO_PITCH_SHIFT_FFT(Synth_STEREO_PITCH_SHIFT_FFT_base* b) : Arts::Object(b), _cache(0) {}
  1439.  
  1440.  
  1441. public:
  1442.     typedef Synth_STEREO_PITCH_SHIFT_FFT_base _base_class;
  1443.  
  1444.     inline Synth_STEREO_PITCH_SHIFT_FFT() : Arts::Object(_Creator), _cache(0) {}
  1445.     inline Synth_STEREO_PITCH_SHIFT_FFT(const Arts::SubClass& s) :
  1446.         Arts::Object(Synth_STEREO_PITCH_SHIFT_FFT_base::_create(s.string())), _cache(0) {}
  1447.     inline Synth_STEREO_PITCH_SHIFT_FFT(const Arts::Reference &r) :
  1448.         Arts::Object(r.isString()?(Synth_STEREO_PITCH_SHIFT_FFT_base::_fromString(r.string())):(Synth_STEREO_PITCH_SHIFT_FFT_base::_fromReference(r.reference(),true))), _cache(0) {}
  1449.     inline Synth_STEREO_PITCH_SHIFT_FFT(const Arts::DynamicCast& c) : Arts::Object(Synth_STEREO_PITCH_SHIFT_FFT_base::_fromDynamicCast(c.object())), _cache(0) {}
  1450.     inline Synth_STEREO_PITCH_SHIFT_FFT(const Synth_STEREO_PITCH_SHIFT_FFT& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1451.     inline Synth_STEREO_PITCH_SHIFT_FFT(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1452.     inline static Synth_STEREO_PITCH_SHIFT_FFT null() {return Synth_STEREO_PITCH_SHIFT_FFT((Synth_STEREO_PITCH_SHIFT_FFT_base*)0);}
  1453.     inline static Synth_STEREO_PITCH_SHIFT_FFT _from_base(Synth_STEREO_PITCH_SHIFT_FFT_base* b) {return Synth_STEREO_PITCH_SHIFT_FFT(b);}
  1454.     inline Synth_STEREO_PITCH_SHIFT_FFT& operator=(const Synth_STEREO_PITCH_SHIFT_FFT& target) {
  1455.         if (_pool == target._pool) return *this;
  1456.         _pool->Dec();
  1457.         _pool = target._pool;
  1458.         _cache = target._cache;
  1459.         _pool->Inc();
  1460.         return *this;
  1461.     }
  1462.     inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
  1463.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  1464.     inline Synth_STEREO_PITCH_SHIFT_FFT_base* _base() {return _cache?_cache:_method_call();}
  1465.  
  1466.     inline Arts::AutoSuspendState autoSuspend();
  1467.     inline void start();
  1468.     inline void stop();
  1469.     inline void streamInit();
  1470.     inline void streamStart();
  1471.     inline void streamEnd();
  1472.     inline float speed();
  1473.     inline void speed(float _newValue);
  1474.     inline float scaleFactor();
  1475.     inline void scaleFactor(float _newValue);
  1476.     inline long frameSize();
  1477.     inline void frameSize(long _newValue);
  1478.     inline long oversample();
  1479.     inline void oversample(long _newValue);
  1480. };
  1481.  
  1482. class ARTS_EXPORT Synth_STEREO_FIR_EQUALIZER_base : virtual public Arts::StereoEffect_base {
  1483. public:
  1484.     static unsigned long _IID; // interface ID
  1485.  
  1486.     static Synth_STEREO_FIR_EQUALIZER_base *_create(const std::string& subClass = "Arts::Synth_STEREO_FIR_EQUALIZER");
  1487.     static Synth_STEREO_FIR_EQUALIZER_base *_fromString(const std::string& objectref);
  1488.     static Synth_STEREO_FIR_EQUALIZER_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1489.  
  1490.     static Synth_STEREO_FIR_EQUALIZER_base *_fromDynamicCast(const Arts::Object& object);
  1491.     inline Synth_STEREO_FIR_EQUALIZER_base *_copy() {
  1492.         assert(_refCnt > 0);
  1493.         _refCnt++;
  1494.         return this;
  1495.     }
  1496.  
  1497.     virtual std::vector<std::string> _defaultPortsIn() const;
  1498.     virtual std::vector<std::string> _defaultPortsOut() const;
  1499.  
  1500.     void *_cast(unsigned long iid);
  1501.  
  1502.     virtual std::vector<Arts::GraphPoint> * frequencies() = 0;
  1503.     virtual void frequencies(const std::vector<Arts::GraphPoint>& newValue) = 0;
  1504.     virtual long taps() = 0;
  1505.     virtual void taps(long newValue) = 0;
  1506. };
  1507.  
  1508. class ARTS_EXPORT Synth_STEREO_FIR_EQUALIZER_stub : virtual public Synth_STEREO_FIR_EQUALIZER_base, virtual public Arts::StereoEffect_stub {
  1509. protected:
  1510.     Synth_STEREO_FIR_EQUALIZER_stub();
  1511.  
  1512. public:
  1513.     Synth_STEREO_FIR_EQUALIZER_stub(Arts::Connection *connection, long objectID);
  1514.  
  1515.     std::vector<Arts::GraphPoint> * frequencies();
  1516.     void frequencies(const std::vector<Arts::GraphPoint>& newValue);
  1517.     long taps();
  1518.     void taps(long newValue);
  1519. };
  1520.  
  1521. class ARTS_EXPORT Synth_STEREO_FIR_EQUALIZER_skel : virtual public Synth_STEREO_FIR_EQUALIZER_base, virtual public Arts::StereoEffect_skel {
  1522. protected:
  1523.     // emitters for change notifications
  1524.     inline void taps_changed(long newValue) {
  1525.         _emit_changed("taps_changed",newValue);
  1526.     }
  1527.  
  1528. public:
  1529.     Synth_STEREO_FIR_EQUALIZER_skel();
  1530.  
  1531.     static std::string _interfaceNameSkel();
  1532.     std::string _interfaceName();
  1533.     bool _isCompatibleWith(const std::string& interfacename);
  1534.     void _buildMethodTable();
  1535.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1536. };
  1537.  
  1538. }
  1539. #include "reference.h"
  1540. namespace Arts {
  1541. class ARTS_EXPORT Synth_STEREO_FIR_EQUALIZER : public Arts::Object {
  1542. private:
  1543.     static Arts::Object_base* _Creator();
  1544.     Synth_STEREO_FIR_EQUALIZER_base *_cache;
  1545.     inline Synth_STEREO_FIR_EQUALIZER_base *_method_call() {
  1546.         _pool->checkcreate();
  1547.         if(_pool->base) {
  1548.             _cache=(Synth_STEREO_FIR_EQUALIZER_base *)_pool->base->_cast(Synth_STEREO_FIR_EQUALIZER_base::_IID);
  1549.             assert(_cache);
  1550.         }
  1551.         return _cache;
  1552.     }
  1553.  
  1554. protected:
  1555.     inline Synth_STEREO_FIR_EQUALIZER(Synth_STEREO_FIR_EQUALIZER_base* b) : Arts::Object(b), _cache(0) {}
  1556.  
  1557.  
  1558. public:
  1559.     typedef Synth_STEREO_FIR_EQUALIZER_base _base_class;
  1560.  
  1561.     inline Synth_STEREO_FIR_EQUALIZER() : Arts::Object(_Creator), _cache(0) {}
  1562.     inline Synth_STEREO_FIR_EQUALIZER(const Arts::SubClass& s) :
  1563.         Arts::Object(Synth_STEREO_FIR_EQUALIZER_base::_create(s.string())), _cache(0) {}
  1564.     inline Synth_STEREO_FIR_EQUALIZER(const Arts::Reference &r) :
  1565.         Arts::Object(r.isString()?(Synth_STEREO_FIR_EQUALIZER_base::_fromString(r.string())):(Synth_STEREO_FIR_EQUALIZER_base::_fromReference(r.reference(),true))), _cache(0) {}
  1566.     inline Synth_STEREO_FIR_EQUALIZER(const Arts::DynamicCast& c) : Arts::Object(Synth_STEREO_FIR_EQUALIZER_base::_fromDynamicCast(c.object())), _cache(0) {}
  1567.     inline Synth_STEREO_FIR_EQUALIZER(const Synth_STEREO_FIR_EQUALIZER& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1568.     inline Synth_STEREO_FIR_EQUALIZER(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1569.     inline static Synth_STEREO_FIR_EQUALIZER null() {return Synth_STEREO_FIR_EQUALIZER((Synth_STEREO_FIR_EQUALIZER_base*)0);}
  1570.     inline static Synth_STEREO_FIR_EQUALIZER _from_base(Synth_STEREO_FIR_EQUALIZER_base* b) {return Synth_STEREO_FIR_EQUALIZER(b);}
  1571.     inline Synth_STEREO_FIR_EQUALIZER& operator=(const Synth_STEREO_FIR_EQUALIZER& target) {
  1572.         if (_pool == target._pool) return *this;
  1573.         _pool->Dec();
  1574.         _pool = target._pool;
  1575.         _cache = target._cache;
  1576.         _pool->Inc();
  1577.         return *this;
  1578.     }
  1579.     inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
  1580.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  1581.     inline Synth_STEREO_FIR_EQUALIZER_base* _base() {return _cache?_cache:_method_call();}
  1582.  
  1583.     inline Arts::AutoSuspendState autoSuspend();
  1584.     inline void start();
  1585.     inline void stop();
  1586.     inline void streamInit();
  1587.     inline void streamStart();
  1588.     inline void streamEnd();
  1589.     inline std::vector<Arts::GraphPoint> * frequencies();
  1590.     inline void frequencies(const std::vector<Arts::GraphPoint>& _newValue);
  1591.     inline long taps();
  1592.     inline void taps(long _newValue);
  1593. };
  1594.  
  1595. class ARTS_EXPORT StereoFirEqualizerGuiFactory_base : virtual public Arts::GuiFactory_base {
  1596. public:
  1597.     static unsigned long _IID; // interface ID
  1598.  
  1599.     static StereoFirEqualizerGuiFactory_base *_create(const std::string& subClass = "Arts::StereoFirEqualizerGuiFactory");
  1600.     static StereoFirEqualizerGuiFactory_base *_fromString(const std::string& objectref);
  1601.     static StereoFirEqualizerGuiFactory_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1602.  
  1603.     static StereoFirEqualizerGuiFactory_base *_fromDynamicCast(const Arts::Object& object);
  1604.     inline StereoFirEqualizerGuiFactory_base *_copy() {
  1605.         assert(_refCnt > 0);
  1606.         _refCnt++;
  1607.         return this;
  1608.     }
  1609.  
  1610.     virtual std::vector<std::string> _defaultPortsIn() const;
  1611.     virtual std::vector<std::string> _defaultPortsOut() const;
  1612.  
  1613.     void *_cast(unsigned long iid);
  1614.  
  1615. };
  1616.  
  1617. class ARTS_EXPORT StereoFirEqualizerGuiFactory_stub : virtual public StereoFirEqualizerGuiFactory_base, virtual public Arts::GuiFactory_stub {
  1618. protected:
  1619.     StereoFirEqualizerGuiFactory_stub();
  1620.  
  1621. public:
  1622.     StereoFirEqualizerGuiFactory_stub(Arts::Connection *connection, long objectID);
  1623.  
  1624. };
  1625.  
  1626. class ARTS_EXPORT StereoFirEqualizerGuiFactory_skel : virtual public StereoFirEqualizerGuiFactory_base, virtual public Arts::GuiFactory_skel {
  1627. public:
  1628.     StereoFirEqualizerGuiFactory_skel();
  1629.  
  1630.     static std::string _interfaceNameSkel();
  1631.     std::string _interfaceName();
  1632.     bool _isCompatibleWith(const std::string& interfacename);
  1633.     void _buildMethodTable();
  1634.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1635. };
  1636.  
  1637. }
  1638. #include "reference.h"
  1639. namespace Arts {
  1640. class ARTS_EXPORT StereoFirEqualizerGuiFactory : public Arts::Object {
  1641. private:
  1642.     static Arts::Object_base* _Creator();
  1643.     StereoFirEqualizerGuiFactory_base *_cache;
  1644.     inline StereoFirEqualizerGuiFactory_base *_method_call() {
  1645.         _pool->checkcreate();
  1646.         if(_pool->base) {
  1647.             _cache=(StereoFirEqualizerGuiFactory_base *)_pool->base->_cast(StereoFirEqualizerGuiFactory_base::_IID);
  1648.             assert(_cache);
  1649.         }
  1650.         return _cache;
  1651.     }
  1652.  
  1653. protected:
  1654.     inline StereoFirEqualizerGuiFactory(StereoFirEqualizerGuiFactory_base* b) : Arts::Object(b), _cache(0) {}
  1655.  
  1656.  
  1657. public:
  1658.     typedef StereoFirEqualizerGuiFactory_base _base_class;
  1659.  
  1660.     inline StereoFirEqualizerGuiFactory() : Arts::Object(_Creator), _cache(0) {}
  1661.     inline StereoFirEqualizerGuiFactory(const Arts::SubClass& s) :
  1662.         Arts::Object(StereoFirEqualizerGuiFactory_base::_create(s.string())), _cache(0) {}
  1663.     inline StereoFirEqualizerGuiFactory(const Arts::Reference &r) :
  1664.         Arts::Object(r.isString()?(StereoFirEqualizerGuiFactory_base::_fromString(r.string())):(StereoFirEqualizerGuiFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
  1665.     inline StereoFirEqualizerGuiFactory(const Arts::DynamicCast& c) : Arts::Object(StereoFirEqualizerGuiFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
  1666.     inline StereoFirEqualizerGuiFactory(const StereoFirEqualizerGuiFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1667.     inline StereoFirEqualizerGuiFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1668.     inline static StereoFirEqualizerGuiFactory null() {return StereoFirEqualizerGuiFactory((StereoFirEqualizerGuiFactory_base*)0);}
  1669.     inline static StereoFirEqualizerGuiFactory _from_base(StereoFirEqualizerGuiFactory_base* b) {return StereoFirEqualizerGuiFactory(b);}
  1670.     inline StereoFirEqualizerGuiFactory& operator=(const StereoFirEqualizerGuiFactory& target) {
  1671.         if (_pool == target._pool) return *this;
  1672.         _pool->Dec();
  1673.         _pool = target._pool;
  1674.         _cache = target._cache;
  1675.         _pool->Inc();
  1676.         return *this;
  1677.     }
  1678.     inline operator Arts::GuiFactory() const { return Arts::GuiFactory(*_pool); }
  1679.     inline StereoFirEqualizerGuiFactory_base* _base() {return _cache?_cache:_method_call();}
  1680.  
  1681.     inline Arts::Widget createGui(Arts::Object runningObject);
  1682. };
  1683.  
  1684. class ARTS_EXPORT Synth_FREEVERB_base : virtual public Arts::StereoEffect_base {
  1685. public:
  1686.     static unsigned long _IID; // interface ID
  1687.  
  1688.     static Synth_FREEVERB_base *_create(const std::string& subClass = "Arts::Synth_FREEVERB");
  1689.     static Synth_FREEVERB_base *_fromString(const std::string& objectref);
  1690.     static Synth_FREEVERB_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1691.  
  1692.     static Synth_FREEVERB_base *_fromDynamicCast(const Arts::Object& object);
  1693.     inline Synth_FREEVERB_base *_copy() {
  1694.         assert(_refCnt > 0);
  1695.         _refCnt++;
  1696.         return this;
  1697.     }
  1698.  
  1699.     virtual std::vector<std::string> _defaultPortsIn() const;
  1700.     virtual std::vector<std::string> _defaultPortsOut() const;
  1701.  
  1702.     void *_cast(unsigned long iid);
  1703.  
  1704.     virtual float roomsize() = 0;
  1705.     virtual void roomsize(float newValue) = 0;
  1706.     virtual float damp() = 0;
  1707.     virtual void damp(float newValue) = 0;
  1708.     virtual float wet() = 0;
  1709.     virtual void wet(float newValue) = 0;
  1710.     virtual float dry() = 0;
  1711.     virtual void dry(float newValue) = 0;
  1712.     virtual float width() = 0;
  1713.     virtual void width(float newValue) = 0;
  1714.     virtual float mode() = 0;
  1715.     virtual void mode(float newValue) = 0;
  1716. };
  1717.  
  1718. class ARTS_EXPORT Synth_FREEVERB_stub : virtual public Synth_FREEVERB_base, virtual public Arts::StereoEffect_stub {
  1719. protected:
  1720.     Synth_FREEVERB_stub();
  1721.  
  1722. public:
  1723.     Synth_FREEVERB_stub(Arts::Connection *connection, long objectID);
  1724.  
  1725.     float roomsize();
  1726.     void roomsize(float newValue);
  1727.     float damp();
  1728.     void damp(float newValue);
  1729.     float wet();
  1730.     void wet(float newValue);
  1731.     float dry();
  1732.     void dry(float newValue);
  1733.     float width();
  1734.     void width(float newValue);
  1735.     float mode();
  1736.     void mode(float newValue);
  1737. };
  1738.  
  1739. class ARTS_EXPORT Synth_FREEVERB_skel : virtual public Synth_FREEVERB_base, virtual public Arts::StereoEffect_skel {
  1740. protected:
  1741.     // emitters for change notifications
  1742.     inline void roomsize_changed(float newValue) {
  1743.         _emit_changed("roomsize_changed",newValue);
  1744.     }
  1745.     inline void damp_changed(float newValue) {
  1746.         _emit_changed("damp_changed",newValue);
  1747.     }
  1748.     inline void wet_changed(float newValue) {
  1749.         _emit_changed("wet_changed",newValue);
  1750.     }
  1751.     inline void dry_changed(float newValue) {
  1752.         _emit_changed("dry_changed",newValue);
  1753.     }
  1754.     inline void width_changed(float newValue) {
  1755.         _emit_changed("width_changed",newValue);
  1756.     }
  1757.     inline void mode_changed(float newValue) {
  1758.         _emit_changed("mode_changed",newValue);
  1759.     }
  1760.  
  1761. public:
  1762.     Synth_FREEVERB_skel();
  1763.  
  1764.     static std::string _interfaceNameSkel();
  1765.     std::string _interfaceName();
  1766.     bool _isCompatibleWith(const std::string& interfacename);
  1767.     void _buildMethodTable();
  1768.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1769. };
  1770.  
  1771. }
  1772. #include "reference.h"
  1773. namespace Arts {
  1774. class ARTS_EXPORT Synth_FREEVERB : public Arts::Object {
  1775. private:
  1776.     static Arts::Object_base* _Creator();
  1777.     Synth_FREEVERB_base *_cache;
  1778.     inline Synth_FREEVERB_base *_method_call() {
  1779.         _pool->checkcreate();
  1780.         if(_pool->base) {
  1781.             _cache=(Synth_FREEVERB_base *)_pool->base->_cast(Synth_FREEVERB_base::_IID);
  1782.             assert(_cache);
  1783.         }
  1784.         return _cache;
  1785.     }
  1786.  
  1787. protected:
  1788.     inline Synth_FREEVERB(Synth_FREEVERB_base* b) : Arts::Object(b), _cache(0) {}
  1789.  
  1790.  
  1791. public:
  1792.     typedef Synth_FREEVERB_base _base_class;
  1793.  
  1794.     inline Synth_FREEVERB() : Arts::Object(_Creator), _cache(0) {}
  1795.     inline Synth_FREEVERB(const Arts::SubClass& s) :
  1796.         Arts::Object(Synth_FREEVERB_base::_create(s.string())), _cache(0) {}
  1797.     inline Synth_FREEVERB(const Arts::Reference &r) :
  1798.         Arts::Object(r.isString()?(Synth_FREEVERB_base::_fromString(r.string())):(Synth_FREEVERB_base::_fromReference(r.reference(),true))), _cache(0) {}
  1799.     inline Synth_FREEVERB(const Arts::DynamicCast& c) : Arts::Object(Synth_FREEVERB_base::_fromDynamicCast(c.object())), _cache(0) {}
  1800.     inline Synth_FREEVERB(const Synth_FREEVERB& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1801.     inline Synth_FREEVERB(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1802.     inline static Synth_FREEVERB null() {return Synth_FREEVERB((Synth_FREEVERB_base*)0);}
  1803.     inline static Synth_FREEVERB _from_base(Synth_FREEVERB_base* b) {return Synth_FREEVERB(b);}
  1804.     inline Synth_FREEVERB& operator=(const Synth_FREEVERB& target) {
  1805.         if (_pool == target._pool) return *this;
  1806.         _pool->Dec();
  1807.         _pool = target._pool;
  1808.         _cache = target._cache;
  1809.         _pool->Inc();
  1810.         return *this;
  1811.     }
  1812.     inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
  1813.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  1814.     inline Synth_FREEVERB_base* _base() {return _cache?_cache:_method_call();}
  1815.  
  1816.     inline Arts::AutoSuspendState autoSuspend();
  1817.     inline void start();
  1818.     inline void stop();
  1819.     inline void streamInit();
  1820.     inline void streamStart();
  1821.     inline void streamEnd();
  1822.     inline float roomsize();
  1823.     inline void roomsize(float _newValue);
  1824.     inline float damp();
  1825.     inline void damp(float _newValue);
  1826.     inline float wet();
  1827.     inline void wet(float _newValue);
  1828.     inline float dry();
  1829.     inline void dry(float _newValue);
  1830.     inline float width();
  1831.     inline void width(float _newValue);
  1832.     inline float mode();
  1833.     inline void mode(float _newValue);
  1834. };
  1835.  
  1836. class ARTS_EXPORT FreeverbGuiFactory_base : virtual public Arts::GuiFactory_base {
  1837. public:
  1838.     static unsigned long _IID; // interface ID
  1839.  
  1840.     static FreeverbGuiFactory_base *_create(const std::string& subClass = "Arts::FreeverbGuiFactory");
  1841.     static FreeverbGuiFactory_base *_fromString(const std::string& objectref);
  1842.     static FreeverbGuiFactory_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1843.  
  1844.     static FreeverbGuiFactory_base *_fromDynamicCast(const Arts::Object& object);
  1845.     inline FreeverbGuiFactory_base *_copy() {
  1846.         assert(_refCnt > 0);
  1847.         _refCnt++;
  1848.         return this;
  1849.     }
  1850.  
  1851.     virtual std::vector<std::string> _defaultPortsIn() const;
  1852.     virtual std::vector<std::string> _defaultPortsOut() const;
  1853.  
  1854.     void *_cast(unsigned long iid);
  1855.  
  1856. };
  1857.  
  1858. class ARTS_EXPORT FreeverbGuiFactory_stub : virtual public FreeverbGuiFactory_base, virtual public Arts::GuiFactory_stub {
  1859. protected:
  1860.     FreeverbGuiFactory_stub();
  1861.  
  1862. public:
  1863.     FreeverbGuiFactory_stub(Arts::Connection *connection, long objectID);
  1864.  
  1865. };
  1866.  
  1867. class ARTS_EXPORT FreeverbGuiFactory_skel : virtual public FreeverbGuiFactory_base, virtual public Arts::GuiFactory_skel {
  1868. public:
  1869.     FreeverbGuiFactory_skel();
  1870.  
  1871.     static std::string _interfaceNameSkel();
  1872.     std::string _interfaceName();
  1873.     bool _isCompatibleWith(const std::string& interfacename);
  1874.     void _buildMethodTable();
  1875.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1876. };
  1877.  
  1878. }
  1879. #include "reference.h"
  1880. namespace Arts {
  1881. class ARTS_EXPORT FreeverbGuiFactory : public Arts::Object {
  1882. private:
  1883.     static Arts::Object_base* _Creator();
  1884.     FreeverbGuiFactory_base *_cache;
  1885.     inline FreeverbGuiFactory_base *_method_call() {
  1886.         _pool->checkcreate();
  1887.         if(_pool->base) {
  1888.             _cache=(FreeverbGuiFactory_base *)_pool->base->_cast(FreeverbGuiFactory_base::_IID);
  1889.             assert(_cache);
  1890.         }
  1891.         return _cache;
  1892.     }
  1893.  
  1894. protected:
  1895.     inline FreeverbGuiFactory(FreeverbGuiFactory_base* b) : Arts::Object(b), _cache(0) {}
  1896.  
  1897.  
  1898. public:
  1899.     typedef FreeverbGuiFactory_base _base_class;
  1900.  
  1901.     inline FreeverbGuiFactory() : Arts::Object(_Creator), _cache(0) {}
  1902.     inline FreeverbGuiFactory(const Arts::SubClass& s) :
  1903.         Arts::Object(FreeverbGuiFactory_base::_create(s.string())), _cache(0) {}
  1904.     inline FreeverbGuiFactory(const Arts::Reference &r) :
  1905.         Arts::Object(r.isString()?(FreeverbGuiFactory_base::_fromString(r.string())):(FreeverbGuiFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
  1906.     inline FreeverbGuiFactory(const Arts::DynamicCast& c) : Arts::Object(FreeverbGuiFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
  1907.     inline FreeverbGuiFactory(const FreeverbGuiFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1908.     inline FreeverbGuiFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1909.     inline static FreeverbGuiFactory null() {return FreeverbGuiFactory((FreeverbGuiFactory_base*)0);}
  1910.     inline static FreeverbGuiFactory _from_base(FreeverbGuiFactory_base* b) {return FreeverbGuiFactory(b);}
  1911.     inline FreeverbGuiFactory& operator=(const FreeverbGuiFactory& target) {
  1912.         if (_pool == target._pool) return *this;
  1913.         _pool->Dec();
  1914.         _pool = target._pool;
  1915.         _cache = target._cache;
  1916.         _pool->Inc();
  1917.         return *this;
  1918.     }
  1919.     inline operator Arts::GuiFactory() const { return Arts::GuiFactory(*_pool); }
  1920.     inline FreeverbGuiFactory_base* _base() {return _cache?_cache:_method_call();}
  1921.  
  1922.     inline Arts::Widget createGui(Arts::Object runningObject);
  1923. };
  1924.  
  1925. class ARTS_EXPORT Effect_WAVECAPTURE_base : virtual public Arts::StereoEffect_base {
  1926. public:
  1927.     static unsigned long _IID; // interface ID
  1928.  
  1929.     static Effect_WAVECAPTURE_base *_create(const std::string& subClass = "Arts::Effect_WAVECAPTURE");
  1930.     static Effect_WAVECAPTURE_base *_fromString(const std::string& objectref);
  1931.     static Effect_WAVECAPTURE_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1932.  
  1933.     static Effect_WAVECAPTURE_base *_fromDynamicCast(const Arts::Object& object);
  1934.     inline Effect_WAVECAPTURE_base *_copy() {
  1935.         assert(_refCnt > 0);
  1936.         _refCnt++;
  1937.         return this;
  1938.     }
  1939.  
  1940.     virtual std::vector<std::string> _defaultPortsIn() const;
  1941.     virtual std::vector<std::string> _defaultPortsOut() const;
  1942.  
  1943.     void *_cast(unsigned long iid);
  1944.  
  1945.     virtual std::string filename() = 0;
  1946.     virtual void filename(const std::string& newValue) = 0;
  1947. };
  1948.  
  1949. class ARTS_EXPORT Effect_WAVECAPTURE_stub : virtual public Effect_WAVECAPTURE_base, virtual public Arts::StereoEffect_stub {
  1950. protected:
  1951.     Effect_WAVECAPTURE_stub();
  1952.  
  1953. public:
  1954.     Effect_WAVECAPTURE_stub(Arts::Connection *connection, long objectID);
  1955.  
  1956.     std::string filename();
  1957.     void filename(const std::string& newValue);
  1958. };
  1959.  
  1960. class ARTS_EXPORT Effect_WAVECAPTURE_skel : virtual public Effect_WAVECAPTURE_base, virtual public Arts::StereoEffect_skel {
  1961. protected:
  1962.     // emitters for change notifications
  1963.     inline void filename_changed(const std::string& newValue) {
  1964.         _emit_changed("filename_changed",newValue);
  1965.     }
  1966.  
  1967. public:
  1968.     Effect_WAVECAPTURE_skel();
  1969.  
  1970.     static std::string _interfaceNameSkel();
  1971.     std::string _interfaceName();
  1972.     bool _isCompatibleWith(const std::string& interfacename);
  1973.     void _buildMethodTable();
  1974.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1975. };
  1976.  
  1977. }
  1978. #include "reference.h"
  1979. namespace Arts {
  1980. class ARTS_EXPORT Effect_WAVECAPTURE : public Arts::Object {
  1981. private:
  1982.     static Arts::Object_base* _Creator();
  1983.     Effect_WAVECAPTURE_base *_cache;
  1984.     inline Effect_WAVECAPTURE_base *_method_call() {
  1985.         _pool->checkcreate();
  1986.         if(_pool->base) {
  1987.             _cache=(Effect_WAVECAPTURE_base *)_pool->base->_cast(Effect_WAVECAPTURE_base::_IID);
  1988.             assert(_cache);
  1989.         }
  1990.         return _cache;
  1991.     }
  1992.  
  1993. protected:
  1994.     inline Effect_WAVECAPTURE(Effect_WAVECAPTURE_base* b) : Arts::Object(b), _cache(0) {}
  1995.  
  1996.  
  1997. public:
  1998.     typedef Effect_WAVECAPTURE_base _base_class;
  1999.  
  2000.     inline Effect_WAVECAPTURE() : Arts::Object(_Creator), _cache(0) {}
  2001.     inline Effect_WAVECAPTURE(const Arts::SubClass& s) :
  2002.         Arts::Object(Effect_WAVECAPTURE_base::_create(s.string())), _cache(0) {}
  2003.     inline Effect_WAVECAPTURE(const Arts::Reference &r) :
  2004.         Arts::Object(r.isString()?(Effect_WAVECAPTURE_base::_fromString(r.string())):(Effect_WAVECAPTURE_base::_fromReference(r.reference(),true))), _cache(0) {}
  2005.     inline Effect_WAVECAPTURE(const Arts::DynamicCast& c) : Arts::Object(Effect_WAVECAPTURE_base::_fromDynamicCast(c.object())), _cache(0) {}
  2006.     inline Effect_WAVECAPTURE(const Effect_WAVECAPTURE& target) : Arts::Object(target._pool), _cache(target._cache) {}
  2007.     inline Effect_WAVECAPTURE(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  2008.     inline static Effect_WAVECAPTURE null() {return Effect_WAVECAPTURE((Effect_WAVECAPTURE_base*)0);}
  2009.     inline static Effect_WAVECAPTURE _from_base(Effect_WAVECAPTURE_base* b) {return Effect_WAVECAPTURE(b);}
  2010.     inline Effect_WAVECAPTURE& operator=(const Effect_WAVECAPTURE& target) {
  2011.         if (_pool == target._pool) return *this;
  2012.         _pool->Dec();
  2013.         _pool = target._pool;
  2014.         _cache = target._cache;
  2015.         _pool->Inc();
  2016.         return *this;
  2017.     }
  2018.     inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
  2019.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  2020.     inline Effect_WAVECAPTURE_base* _base() {return _cache?_cache:_method_call();}
  2021.  
  2022.     inline Arts::AutoSuspendState autoSuspend();
  2023.     inline void start();
  2024.     inline void stop();
  2025.     inline void streamInit();
  2026.     inline void streamStart();
  2027.     inline void streamEnd();
  2028.     inline std::string filename();
  2029.     inline void filename(const std::string& _newValue);
  2030. };
  2031.  
  2032. class ARTS_EXPORT StereoVolumeControlGui_base : virtual public Arts::LayoutBox_base {
  2033. public:
  2034.     static unsigned long _IID; // interface ID
  2035.  
  2036.     static StereoVolumeControlGui_base *_create(const std::string& subClass = "Arts::StereoVolumeControlGui");
  2037.     static StereoVolumeControlGui_base *_fromString(const std::string& objectref);
  2038.     static StereoVolumeControlGui_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  2039.  
  2040.     static StereoVolumeControlGui_base *_fromDynamicCast(const Arts::Object& object);
  2041.     inline StereoVolumeControlGui_base *_copy() {
  2042.         assert(_refCnt > 0);
  2043.         _refCnt++;
  2044.         return this;
  2045.     }
  2046.  
  2047.     virtual std::vector<std::string> _defaultPortsIn() const;
  2048.     virtual std::vector<std::string> _defaultPortsOut() const;
  2049.  
  2050.     void *_cast(unsigned long iid);
  2051.  
  2052.     virtual std::string title() = 0;
  2053.     virtual void title(const std::string& newValue) = 0;
  2054.     virtual float dbmin() = 0;
  2055.     virtual void dbmin(float newValue) = 0;
  2056.     virtual float dbmax() = 0;
  2057.     virtual void dbmax(float newValue) = 0;
  2058.     virtual Arts::LevelMeter left() = 0;
  2059.     virtual Arts::LevelMeter right() = 0;
  2060.     virtual Arts::VolumeFader fader() = 0;
  2061.     virtual Arts::Tickmarks levelmetertickmarks() = 0;
  2062.     virtual Arts::Tickmarks volumefadertickmarks() = 0;
  2063.     virtual Arts::Label label() = 0;
  2064.     virtual bool couple() = 0;
  2065.     virtual void couple(bool newValue) = 0;
  2066.     virtual void constructor(Arts::StereoVolumeControl svc) = 0;
  2067. };
  2068.  
  2069. class ARTS_EXPORT StereoVolumeControlGui_stub : virtual public StereoVolumeControlGui_base, virtual public Arts::LayoutBox_stub {
  2070. protected:
  2071.     StereoVolumeControlGui_stub();
  2072.  
  2073. public:
  2074.     StereoVolumeControlGui_stub(Arts::Connection *connection, long objectID);
  2075.  
  2076.     std::string title();
  2077.     void title(const std::string& newValue);
  2078.     float dbmin();
  2079.     void dbmin(float newValue);
  2080.     float dbmax();
  2081.     void dbmax(float newValue);
  2082.     Arts::LevelMeter left();
  2083.     Arts::LevelMeter right();
  2084.     Arts::VolumeFader fader();
  2085.     Arts::Tickmarks levelmetertickmarks();
  2086.     Arts::Tickmarks volumefadertickmarks();
  2087.     Arts::Label label();
  2088.     bool couple();
  2089.     void couple(bool newValue);
  2090.     void constructor(Arts::StereoVolumeControl svc);
  2091. };
  2092.  
  2093. class ARTS_EXPORT StereoVolumeControlGui_skel : virtual public StereoVolumeControlGui_base, virtual public Arts::LayoutBox_skel {
  2094. protected:
  2095.     // emitters for change notifications
  2096.     inline void title_changed(const std::string& newValue) {
  2097.         _emit_changed("title_changed",newValue);
  2098.     }
  2099.     inline void dbmin_changed(float newValue) {
  2100.         _emit_changed("dbmin_changed",newValue);
  2101.     }
  2102.     inline void dbmax_changed(float newValue) {
  2103.         _emit_changed("dbmax_changed",newValue);
  2104.     }
  2105.     inline void couple_changed(bool newValue) {
  2106.         _emit_changed("couple_changed",newValue);
  2107.     }
  2108.  
  2109. public:
  2110.     StereoVolumeControlGui_skel();
  2111.  
  2112.     static std::string _interfaceNameSkel();
  2113.     std::string _interfaceName();
  2114.     bool _isCompatibleWith(const std::string& interfacename);
  2115.     void _buildMethodTable();
  2116.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  2117. };
  2118.  
  2119. }
  2120. #include "reference.h"
  2121. namespace Arts {
  2122. class ARTS_EXPORT StereoVolumeControlGui : public Arts::Object {
  2123. private:
  2124.     static Arts::Object_base* _Creator();
  2125.     StereoVolumeControlGui_base *_cache;
  2126.     inline StereoVolumeControlGui_base *_method_call() {
  2127.         _pool->checkcreate();
  2128.         if(_pool->base) {
  2129.             _cache=(StereoVolumeControlGui_base *)_pool->base->_cast(StereoVolumeControlGui_base::_IID);
  2130.             assert(_cache);
  2131.         }
  2132.         return _cache;
  2133.     }
  2134.  
  2135. protected:
  2136.     inline StereoVolumeControlGui(StereoVolumeControlGui_base* b) : Arts::Object(b), _cache(0) {}
  2137.  
  2138.  
  2139. public:
  2140.     typedef StereoVolumeControlGui_base _base_class;
  2141.  
  2142.     inline StereoVolumeControlGui() : Arts::Object(_Creator), _cache(0) {}
  2143.     inline StereoVolumeControlGui(const Arts::SubClass& s) :
  2144.         Arts::Object(StereoVolumeControlGui_base::_create(s.string())), _cache(0) {}
  2145.     inline StereoVolumeControlGui(const Arts::Reference &r) :
  2146.         Arts::Object(r.isString()?(StereoVolumeControlGui_base::_fromString(r.string())):(StereoVolumeControlGui_base::_fromReference(r.reference(),true))), _cache(0) {}
  2147.     inline StereoVolumeControlGui(const Arts::DynamicCast& c) : Arts::Object(StereoVolumeControlGui_base::_fromDynamicCast(c.object())), _cache(0) {}
  2148.     inline StereoVolumeControlGui(const StereoVolumeControlGui& target) : Arts::Object(target._pool), _cache(target._cache) {}
  2149.     inline StereoVolumeControlGui(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  2150.     inline static StereoVolumeControlGui null() {return StereoVolumeControlGui((StereoVolumeControlGui_base*)0);}
  2151.     inline static StereoVolumeControlGui _from_base(StereoVolumeControlGui_base* b) {return StereoVolumeControlGui(b);}
  2152.     inline StereoVolumeControlGui& operator=(const StereoVolumeControlGui& target) {
  2153.         if (_pool == target._pool) return *this;
  2154.         _pool->Dec();
  2155.         _pool = target._pool;
  2156.         _cache = target._cache;
  2157.         _pool->Inc();
  2158.         return *this;
  2159.     }
  2160.     inline operator Arts::LayoutBox() const { return Arts::LayoutBox(*_pool); }
  2161.     inline operator Arts::Frame() const { return Arts::Frame(*_pool); }
  2162.     inline operator Arts::Widget() const { return Arts::Widget(*_pool); }
  2163.     inline StereoVolumeControlGui_base* _base() {return _cache?_cache:_method_call();}
  2164.  
  2165.     inline Arts::Direction direction();
  2166.     inline void direction(Arts::Direction _newValue);
  2167.     inline long spacing();
  2168.     inline void spacing(long _newValue);
  2169.     inline long layoutmargin();
  2170.     inline void layoutmargin(long _newValue);
  2171.     inline void addWidget(Arts::Widget widget, long stretch, long align);
  2172.     inline void addWidget(Arts::Widget widget, long stretch);
  2173.     inline void addWidget(Arts::Widget widget);
  2174.     inline void insertWidget(long position, Arts::Widget widget, long stretch, long align);
  2175.     inline void insertWidget(long position, Arts::Widget widget, long stretch);
  2176.     inline void insertWidget(long position, Arts::Widget widget);
  2177.     inline void addStretch(long stretch);
  2178.     inline void addStretch();
  2179.     inline void addSpace(long space);
  2180.     inline void addStrut(long size);
  2181.     inline void addSeparator(long stretch, long align);
  2182.     inline void addSeparator(long stretch);
  2183.     inline void addSeparator();
  2184.     inline void addLine(long width, long space, long stretch, long align);
  2185.     inline void addLine(long width, long space, long stretch);
  2186.     inline void addLine(long width, long space);
  2187.     inline long margin();
  2188.     inline void margin(long _newValue);
  2189.     inline long linewidth();
  2190.     inline void linewidth(long _newValue);
  2191.     inline long midlinewidth();
  2192.     inline void midlinewidth(long _newValue);
  2193.     inline long framestyle();
  2194.     inline void framestyle(long _newValue);
  2195.     inline Arts::Shape frameshape();
  2196.     inline void frameshape(Arts::Shape _newValue);
  2197.     inline Arts::Shadow frameshadow();
  2198.     inline void frameshadow(Arts::Shadow _newValue);
  2199.     inline StereoVolumeControlGui(Arts::Widget parent);
  2200.     inline long widgetID();
  2201.     inline Arts::Widget parent();
  2202.     inline void parent(Arts::Widget _newValue);
  2203.     inline long x();
  2204.     inline void x(long _newValue);
  2205.     inline long y();
  2206.     inline void y(long _newValue);
  2207.     inline long width();
  2208.     inline void width(long _newValue);
  2209.     inline long height();
  2210.     inline void height(long _newValue);
  2211.     inline bool visible();
  2212.     inline void visible(bool _newValue);
  2213.     inline Arts::SizePolicy hSizePolicy();
  2214.     inline void hSizePolicy(Arts::SizePolicy _newValue);
  2215.     inline Arts::SizePolicy vSizePolicy();
  2216.     inline void vSizePolicy(Arts::SizePolicy _newValue);
  2217.     inline void show();
  2218.     inline void hide();
  2219.     inline std::string title();
  2220.     inline void title(const std::string& _newValue);
  2221.     inline float dbmin();
  2222.     inline void dbmin(float _newValue);
  2223.     inline float dbmax();
  2224.     inline void dbmax(float _newValue);
  2225.     inline Arts::LevelMeter left();
  2226.     inline Arts::LevelMeter right();
  2227.     inline Arts::VolumeFader fader();
  2228.     inline Arts::Tickmarks levelmetertickmarks();
  2229.     inline Arts::Tickmarks volumefadertickmarks();
  2230.     inline Arts::Label label();
  2231.     inline bool couple();
  2232.     inline void couple(bool _newValue);
  2233.     inline StereoVolumeControlGui(Arts::StereoVolumeControl svc);
  2234. };
  2235.  
  2236. class ARTS_EXPORT StereoVolumeControlGuiFactory_base : virtual public Arts::GuiFactory_base {
  2237. public:
  2238.     static unsigned long _IID; // interface ID
  2239.  
  2240.     static StereoVolumeControlGuiFactory_base *_create(const std::string& subClass = "Arts::StereoVolumeControlGuiFactory");
  2241.     static StereoVolumeControlGuiFactory_base *_fromString(const std::string& objectref);
  2242.     static StereoVolumeControlGuiFactory_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  2243.  
  2244.     static StereoVolumeControlGuiFactory_base *_fromDynamicCast(const Arts::Object& object);
  2245.     inline StereoVolumeControlGuiFactory_base *_copy() {
  2246.         assert(_refCnt > 0);
  2247.         _refCnt++;
  2248.         return this;
  2249.     }
  2250.  
  2251.     virtual std::vector<std::string> _defaultPortsIn() const;
  2252.     virtual std::vector<std::string> _defaultPortsOut() const;
  2253.  
  2254.     void *_cast(unsigned long iid);
  2255.  
  2256. };
  2257.  
  2258. class ARTS_EXPORT StereoVolumeControlGuiFactory_stub : virtual public StereoVolumeControlGuiFactory_base, virtual public Arts::GuiFactory_stub {
  2259. protected:
  2260.     StereoVolumeControlGuiFactory_stub();
  2261.  
  2262. public:
  2263.     StereoVolumeControlGuiFactory_stub(Arts::Connection *connection, long objectID);
  2264.  
  2265. };
  2266.  
  2267. class ARTS_EXPORT StereoVolumeControlGuiFactory_skel : virtual public StereoVolumeControlGuiFactory_base, virtual public Arts::GuiFactory_skel {
  2268. public:
  2269.     StereoVolumeControlGuiFactory_skel();
  2270.  
  2271.     static std::string _interfaceNameSkel();
  2272.     std::string _interfaceName();
  2273.     bool _isCompatibleWith(const std::string& interfacename);
  2274.     void _buildMethodTable();
  2275.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  2276. };
  2277.  
  2278. }
  2279. #include "reference.h"
  2280. namespace Arts {
  2281. class ARTS_EXPORT StereoVolumeControlGuiFactory : public Arts::Object {
  2282. private:
  2283.     static Arts::Object_base* _Creator();
  2284.     StereoVolumeControlGuiFactory_base *_cache;
  2285.     inline StereoVolumeControlGuiFactory_base *_method_call() {
  2286.         _pool->checkcreate();
  2287.         if(_pool->base) {
  2288.             _cache=(StereoVolumeControlGuiFactory_base *)_pool->base->_cast(StereoVolumeControlGuiFactory_base::_IID);
  2289.             assert(_cache);
  2290.         }
  2291.         return _cache;
  2292.     }
  2293.  
  2294. protected:
  2295.     inline StereoVolumeControlGuiFactory(StereoVolumeControlGuiFactory_base* b) : Arts::Object(b), _cache(0) {}
  2296.  
  2297.  
  2298. public:
  2299.     typedef StereoVolumeControlGuiFactory_base _base_class;
  2300.  
  2301.     inline StereoVolumeControlGuiFactory() : Arts::Object(_Creator), _cache(0) {}
  2302.     inline StereoVolumeControlGuiFactory(const Arts::SubClass& s) :
  2303.         Arts::Object(StereoVolumeControlGuiFactory_base::_create(s.string())), _cache(0) {}
  2304.     inline StereoVolumeControlGuiFactory(const Arts::Reference &r) :
  2305.         Arts::Object(r.isString()?(StereoVolumeControlGuiFactory_base::_fromString(r.string())):(StereoVolumeControlGuiFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
  2306.     inline StereoVolumeControlGuiFactory(const Arts::DynamicCast& c) : Arts::Object(StereoVolumeControlGuiFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
  2307.     inline StereoVolumeControlGuiFactory(const StereoVolumeControlGuiFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
  2308.     inline StereoVolumeControlGuiFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  2309.     inline static StereoVolumeControlGuiFactory null() {return StereoVolumeControlGuiFactory((StereoVolumeControlGuiFactory_base*)0);}
  2310.     inline static StereoVolumeControlGuiFactory _from_base(StereoVolumeControlGuiFactory_base* b) {return StereoVolumeControlGuiFactory(b);}
  2311.     inline StereoVolumeControlGuiFactory& operator=(const StereoVolumeControlGuiFactory& target) {
  2312.         if (_pool == target._pool) return *this;
  2313.         _pool->Dec();
  2314.         _pool = target._pool;
  2315.         _cache = target._cache;
  2316.         _pool->Inc();
  2317.         return *this;
  2318.     }
  2319.     inline operator Arts::GuiFactory() const { return Arts::GuiFactory(*_pool); }
  2320.     inline StereoVolumeControlGuiFactory_base* _base() {return _cache?_cache:_method_call();}
  2321.  
  2322.     inline Arts::Widget createGui(Arts::Object runningObject);
  2323. };
  2324.  
  2325. }
  2326. // Forward wrapper calls to _base classes:
  2327.  
  2328. inline Arts::AutoSuspendState Arts::StereoToMono::autoSuspend()
  2329. {
  2330.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  2331. }
  2332.  
  2333. inline void Arts::StereoToMono::start()
  2334. {
  2335.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  2336. }
  2337.  
  2338. inline void Arts::StereoToMono::stop()
  2339. {
  2340.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  2341. }
  2342.  
  2343. inline void Arts::StereoToMono::streamInit()
  2344. {
  2345.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  2346. }
  2347.  
  2348. inline void Arts::StereoToMono::streamStart()
  2349. {
  2350.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  2351. }
  2352.  
  2353. inline void Arts::StereoToMono::streamEnd()
  2354. {
  2355.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  2356. }
  2357.  
  2358. inline float Arts::StereoToMono::pan()
  2359. {
  2360.     return _cache?static_cast<Arts::StereoToMono_base*>(_cache)->pan():static_cast<Arts::StereoToMono_base*>(_method_call())->pan();
  2361. }
  2362.  
  2363. inline void Arts::StereoToMono::pan(float _newValue)
  2364. {
  2365.      _cache?static_cast<Arts::StereoToMono_base*>(_cache)->pan(_newValue):static_cast<Arts::StereoToMono_base*>(_method_call())->pan(_newValue);
  2366. }
  2367.  
  2368. inline Arts::AutoSuspendState Arts::MonoToStereo::autoSuspend()
  2369. {
  2370.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  2371. }
  2372.  
  2373. inline void Arts::MonoToStereo::start()
  2374. {
  2375.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  2376. }
  2377.  
  2378. inline void Arts::MonoToStereo::stop()
  2379. {
  2380.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  2381. }
  2382.  
  2383. inline void Arts::MonoToStereo::streamInit()
  2384. {
  2385.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  2386. }
  2387.  
  2388. inline void Arts::MonoToStereo::streamStart()
  2389. {
  2390.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  2391. }
  2392.  
  2393. inline void Arts::MonoToStereo::streamEnd()
  2394. {
  2395.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  2396. }
  2397.  
  2398. inline float Arts::MonoToStereo::pan()
  2399. {
  2400.     return _cache?static_cast<Arts::MonoToStereo_base*>(_cache)->pan():static_cast<Arts::MonoToStereo_base*>(_method_call())->pan();
  2401. }
  2402.  
  2403. inline void Arts::MonoToStereo::pan(float _newValue)
  2404. {
  2405.      _cache?static_cast<Arts::MonoToStereo_base*>(_cache)->pan(_newValue):static_cast<Arts::MonoToStereo_base*>(_method_call())->pan(_newValue);
  2406. }
  2407.  
  2408. inline Arts::AutoSuspendState Arts::StereoBalance::autoSuspend()
  2409. {
  2410.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  2411. }
  2412.  
  2413. inline void Arts::StereoBalance::start()
  2414. {
  2415.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  2416. }
  2417.  
  2418. inline void Arts::StereoBalance::stop()
  2419. {
  2420.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  2421. }
  2422.  
  2423. inline void Arts::StereoBalance::streamInit()
  2424. {
  2425.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  2426. }
  2427.  
  2428. inline void Arts::StereoBalance::streamStart()
  2429. {
  2430.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  2431. }
  2432.  
  2433. inline void Arts::StereoBalance::streamEnd()
  2434. {
  2435.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  2436. }
  2437.  
  2438. inline float Arts::StereoBalance::balance()
  2439. {
  2440.     return _cache?static_cast<Arts::StereoBalance_base*>(_cache)->balance():static_cast<Arts::StereoBalance_base*>(_method_call())->balance();
  2441. }
  2442.  
  2443. inline void Arts::StereoBalance::balance(float _newValue)
  2444. {
  2445.      _cache?static_cast<Arts::StereoBalance_base*>(_cache)->balance(_newValue):static_cast<Arts::StereoBalance_base*>(_method_call())->balance(_newValue);
  2446. }
  2447.  
  2448. inline Arts::Widget Arts::StereoBalanceGuiFactory::createGui(Arts::Object runningObject)
  2449. {
  2450.     return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
  2451. }
  2452.  
  2453. inline Arts::AutoSuspendState Arts::FiveBandMonoComplexEQ::autoSuspend()
  2454. {
  2455.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  2456. }
  2457.  
  2458. inline void Arts::FiveBandMonoComplexEQ::start()
  2459. {
  2460.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  2461. }
  2462.  
  2463. inline void Arts::FiveBandMonoComplexEQ::stop()
  2464. {
  2465.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  2466. }
  2467.  
  2468. inline void Arts::FiveBandMonoComplexEQ::streamInit()
  2469. {
  2470.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  2471. }
  2472.  
  2473. inline void Arts::FiveBandMonoComplexEQ::streamStart()
  2474. {
  2475.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  2476. }
  2477.  
  2478. inline void Arts::FiveBandMonoComplexEQ::streamEnd()
  2479. {
  2480.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  2481. }
  2482.  
  2483. inline Arts::StereoToMono Arts::FiveBandMonoComplexEQ::s2m()
  2484. {
  2485.     return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->s2m():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->s2m();
  2486. }
  2487.  
  2488. inline float Arts::FiveBandMonoComplexEQ::lowfreq()
  2489. {
  2490.     return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->lowfreq():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->lowfreq();
  2491. }
  2492.  
  2493. inline void Arts::FiveBandMonoComplexEQ::lowfreq(float _newValue)
  2494. {
  2495.      _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->lowfreq(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->lowfreq(_newValue);
  2496. }
  2497.  
  2498. inline float Arts::FiveBandMonoComplexEQ::lowq()
  2499. {
  2500.     return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->lowq():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->lowq();
  2501. }
  2502.  
  2503. inline void Arts::FiveBandMonoComplexEQ::lowq(float _newValue)
  2504. {
  2505.      _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->lowq(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->lowq(_newValue);
  2506. }
  2507.  
  2508. inline float Arts::FiveBandMonoComplexEQ::lowgain()
  2509. {
  2510.     return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->lowgain():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->lowgain();
  2511. }
  2512.  
  2513. inline void Arts::FiveBandMonoComplexEQ::lowgain(float _newValue)
  2514. {
  2515.      _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->lowgain(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->lowgain(_newValue);
  2516. }
  2517.  
  2518. inline float Arts::FiveBandMonoComplexEQ::mid1freq()
  2519. {
  2520.     return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid1freq():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid1freq();
  2521. }
  2522.  
  2523. inline void Arts::FiveBandMonoComplexEQ::mid1freq(float _newValue)
  2524. {
  2525.      _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid1freq(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid1freq(_newValue);
  2526. }
  2527.  
  2528. inline float Arts::FiveBandMonoComplexEQ::mid1q()
  2529. {
  2530.     return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid1q():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid1q();
  2531. }
  2532.  
  2533. inline void Arts::FiveBandMonoComplexEQ::mid1q(float _newValue)
  2534. {
  2535.      _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid1q(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid1q(_newValue);
  2536. }
  2537.  
  2538. inline float Arts::FiveBandMonoComplexEQ::mid1gain()
  2539. {
  2540.     return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid1gain():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid1gain();
  2541. }
  2542.  
  2543. inline void Arts::FiveBandMonoComplexEQ::mid1gain(float _newValue)
  2544. {
  2545.      _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid1gain(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid1gain(_newValue);
  2546. }
  2547.  
  2548. inline float Arts::FiveBandMonoComplexEQ::mid2freq()
  2549. {
  2550.     return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid2freq():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid2freq();
  2551. }
  2552.  
  2553. inline void Arts::FiveBandMonoComplexEQ::mid2freq(float _newValue)
  2554. {
  2555.      _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid2freq(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid2freq(_newValue);
  2556. }
  2557.  
  2558. inline float Arts::FiveBandMonoComplexEQ::mid2q()
  2559. {
  2560.     return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid2q():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid2q();
  2561. }
  2562.  
  2563. inline void Arts::FiveBandMonoComplexEQ::mid2q(float _newValue)
  2564. {
  2565.      _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid2q(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid2q(_newValue);
  2566. }
  2567.  
  2568. inline float Arts::FiveBandMonoComplexEQ::mid2gain()
  2569. {
  2570.     return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid2gain():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid2gain();
  2571. }
  2572.  
  2573. inline void Arts::FiveBandMonoComplexEQ::mid2gain(float _newValue)
  2574. {
  2575.      _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid2gain(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid2gain(_newValue);
  2576. }
  2577.  
  2578. inline float Arts::FiveBandMonoComplexEQ::mid3freq()
  2579. {
  2580.     return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid3freq():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid3freq();
  2581. }
  2582.  
  2583. inline void Arts::FiveBandMonoComplexEQ::mid3freq(float _newValue)
  2584. {
  2585.      _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid3freq(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid3freq(_newValue);
  2586. }
  2587.  
  2588. inline float Arts::FiveBandMonoComplexEQ::mid3q()
  2589. {
  2590.     return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid3q():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid3q();
  2591. }
  2592.  
  2593. inline void Arts::FiveBandMonoComplexEQ::mid3q(float _newValue)
  2594. {
  2595.      _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid3q(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid3q(_newValue);
  2596. }
  2597.  
  2598. inline float Arts::FiveBandMonoComplexEQ::mid3gain()
  2599. {
  2600.     return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid3gain():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid3gain();
  2601. }
  2602.  
  2603. inline void Arts::FiveBandMonoComplexEQ::mid3gain(float _newValue)
  2604. {
  2605.      _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid3gain(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid3gain(_newValue);
  2606. }
  2607.  
  2608. inline float Arts::FiveBandMonoComplexEQ::highfreq()
  2609. {
  2610.     return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->highfreq():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->highfreq();
  2611. }
  2612.  
  2613. inline void Arts::FiveBandMonoComplexEQ::highfreq(float _newValue)
  2614. {
  2615.      _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->highfreq(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->highfreq(_newValue);
  2616. }
  2617.  
  2618. inline float Arts::FiveBandMonoComplexEQ::highq()
  2619. {
  2620.     return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->highq():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->highq();
  2621. }
  2622.  
  2623. inline void Arts::FiveBandMonoComplexEQ::highq(float _newValue)
  2624. {
  2625.      _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->highq(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->highq(_newValue);
  2626. }
  2627.  
  2628. inline float Arts::FiveBandMonoComplexEQ::highgain()
  2629. {
  2630.     return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->highgain():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->highgain();
  2631. }
  2632.  
  2633. inline void Arts::FiveBandMonoComplexEQ::highgain(float _newValue)
  2634. {
  2635.      _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->highgain(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->highgain(_newValue);
  2636. }
  2637.  
  2638. inline Arts::MonoToStereo Arts::FiveBandMonoComplexEQ::m2s()
  2639. {
  2640.     return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->m2s():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->m2s();
  2641. }
  2642.  
  2643. inline Arts::Widget Arts::FiveBandMonoComplexEQGuiFactory::createGui(Arts::Object runningObject)
  2644. {
  2645.     return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
  2646. }
  2647.  
  2648. inline Arts::AutoSuspendState Arts::Synth_VOICE_REMOVAL::autoSuspend()
  2649. {
  2650.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  2651. }
  2652.  
  2653. inline void Arts::Synth_VOICE_REMOVAL::start()
  2654. {
  2655.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  2656. }
  2657.  
  2658. inline void Arts::Synth_VOICE_REMOVAL::stop()
  2659. {
  2660.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  2661. }
  2662.  
  2663. inline void Arts::Synth_VOICE_REMOVAL::streamInit()
  2664. {
  2665.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  2666. }
  2667.  
  2668. inline void Arts::Synth_VOICE_REMOVAL::streamStart()
  2669. {
  2670.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  2671. }
  2672.  
  2673. inline void Arts::Synth_VOICE_REMOVAL::streamEnd()
  2674. {
  2675.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  2676. }
  2677.  
  2678. inline float Arts::Synth_VOICE_REMOVAL::position()
  2679. {
  2680.     return _cache?static_cast<Arts::Synth_VOICE_REMOVAL_base*>(_cache)->position():static_cast<Arts::Synth_VOICE_REMOVAL_base*>(_method_call())->position();
  2681. }
  2682.  
  2683. inline void Arts::Synth_VOICE_REMOVAL::position(float _newValue)
  2684. {
  2685.      _cache?static_cast<Arts::Synth_VOICE_REMOVAL_base*>(_cache)->position(_newValue):static_cast<Arts::Synth_VOICE_REMOVAL_base*>(_method_call())->position(_newValue);
  2686. }
  2687.  
  2688. inline float Arts::Synth_VOICE_REMOVAL::frequency()
  2689. {
  2690.     return _cache?static_cast<Arts::Synth_VOICE_REMOVAL_base*>(_cache)->frequency():static_cast<Arts::Synth_VOICE_REMOVAL_base*>(_method_call())->frequency();
  2691. }
  2692.  
  2693. inline void Arts::Synth_VOICE_REMOVAL::frequency(float _newValue)
  2694. {
  2695.      _cache?static_cast<Arts::Synth_VOICE_REMOVAL_base*>(_cache)->frequency(_newValue):static_cast<Arts::Synth_VOICE_REMOVAL_base*>(_method_call())->frequency(_newValue);
  2696. }
  2697.  
  2698. inline Arts::Widget Arts::VoiceRemovalGuiFactory::createGui(Arts::Object runningObject)
  2699. {
  2700.     return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
  2701. }
  2702.  
  2703. inline Arts::AutoSuspendState Arts::Synth_STEREO_COMPRESSOR::autoSuspend()
  2704. {
  2705.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  2706. }
  2707.  
  2708. inline void Arts::Synth_STEREO_COMPRESSOR::start()
  2709. {
  2710.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  2711. }
  2712.  
  2713. inline void Arts::Synth_STEREO_COMPRESSOR::stop()
  2714. {
  2715.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  2716. }
  2717.  
  2718. inline void Arts::Synth_STEREO_COMPRESSOR::streamInit()
  2719. {
  2720.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  2721. }
  2722.  
  2723. inline void Arts::Synth_STEREO_COMPRESSOR::streamStart()
  2724. {
  2725.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  2726. }
  2727.  
  2728. inline void Arts::Synth_STEREO_COMPRESSOR::streamEnd()
  2729. {
  2730.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  2731. }
  2732.  
  2733. inline float Arts::Synth_STEREO_COMPRESSOR::attack()
  2734. {
  2735.     return _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->attack():static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->attack();
  2736. }
  2737.  
  2738. inline void Arts::Synth_STEREO_COMPRESSOR::attack(float _newValue)
  2739. {
  2740.      _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->attack(_newValue):static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->attack(_newValue);
  2741. }
  2742.  
  2743. inline float Arts::Synth_STEREO_COMPRESSOR::release()
  2744. {
  2745.     return _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->release():static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->release();
  2746. }
  2747.  
  2748. inline void Arts::Synth_STEREO_COMPRESSOR::release(float _newValue)
  2749. {
  2750.      _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->release(_newValue):static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->release(_newValue);
  2751. }
  2752.  
  2753. inline float Arts::Synth_STEREO_COMPRESSOR::threshold()
  2754. {
  2755.     return _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->threshold():static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->threshold();
  2756. }
  2757.  
  2758. inline void Arts::Synth_STEREO_COMPRESSOR::threshold(float _newValue)
  2759. {
  2760.      _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->threshold(_newValue):static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->threshold(_newValue);
  2761. }
  2762.  
  2763. inline float Arts::Synth_STEREO_COMPRESSOR::ratio()
  2764. {
  2765.     return _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->ratio():static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->ratio();
  2766. }
  2767.  
  2768. inline void Arts::Synth_STEREO_COMPRESSOR::ratio(float _newValue)
  2769. {
  2770.      _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->ratio(_newValue):static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->ratio(_newValue);
  2771. }
  2772.  
  2773. inline float Arts::Synth_STEREO_COMPRESSOR::output()
  2774. {
  2775.     return _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->output():static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->output();
  2776. }
  2777.  
  2778. inline void Arts::Synth_STEREO_COMPRESSOR::output(float _newValue)
  2779. {
  2780.      _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->output(_newValue):static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->output(_newValue);
  2781. }
  2782.  
  2783. inline bool Arts::Synth_STEREO_COMPRESSOR::thru()
  2784. {
  2785.     return _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->thru():static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->thru();
  2786. }
  2787.  
  2788. inline void Arts::Synth_STEREO_COMPRESSOR::thru(bool _newValue)
  2789. {
  2790.      _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->thru(_newValue):static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->thru(_newValue);
  2791. }
  2792.  
  2793. inline Arts::Widget Arts::StereoCompressorGuiFactory::createGui(Arts::Object runningObject)
  2794. {
  2795.     return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
  2796. }
  2797.  
  2798. inline Arts::AutoSuspendState Arts::Synth_STEREO_PITCH_SHIFT::autoSuspend()
  2799. {
  2800.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  2801. }
  2802.  
  2803. inline void Arts::Synth_STEREO_PITCH_SHIFT::start()
  2804. {
  2805.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  2806. }
  2807.  
  2808. inline void Arts::Synth_STEREO_PITCH_SHIFT::stop()
  2809. {
  2810.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  2811. }
  2812.  
  2813. inline void Arts::Synth_STEREO_PITCH_SHIFT::streamInit()
  2814. {
  2815.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  2816. }
  2817.  
  2818. inline void Arts::Synth_STEREO_PITCH_SHIFT::streamStart()
  2819. {
  2820.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  2821. }
  2822.  
  2823. inline void Arts::Synth_STEREO_PITCH_SHIFT::streamEnd()
  2824. {
  2825.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  2826. }
  2827.  
  2828. inline float Arts::Synth_STEREO_PITCH_SHIFT::speed()
  2829. {
  2830.     return _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_base*>(_cache)->speed():static_cast<Arts::Synth_STEREO_PITCH_SHIFT_base*>(_method_call())->speed();
  2831. }
  2832.  
  2833. inline void Arts::Synth_STEREO_PITCH_SHIFT::speed(float _newValue)
  2834. {
  2835.      _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_base*>(_cache)->speed(_newValue):static_cast<Arts::Synth_STEREO_PITCH_SHIFT_base*>(_method_call())->speed(_newValue);
  2836. }
  2837.  
  2838. inline float Arts::Synth_STEREO_PITCH_SHIFT::frequency()
  2839. {
  2840.     return _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_base*>(_cache)->frequency():static_cast<Arts::Synth_STEREO_PITCH_SHIFT_base*>(_method_call())->frequency();
  2841. }
  2842.  
  2843. inline void Arts::Synth_STEREO_PITCH_SHIFT::frequency(float _newValue)
  2844. {
  2845.      _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_base*>(_cache)->frequency(_newValue):static_cast<Arts::Synth_STEREO_PITCH_SHIFT_base*>(_method_call())->frequency(_newValue);
  2846. }
  2847.  
  2848. inline Arts::AutoSuspendState Arts::Synth_STEREO_PITCH_SHIFT_FFT::autoSuspend()
  2849. {
  2850.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  2851. }
  2852.  
  2853. inline void Arts::Synth_STEREO_PITCH_SHIFT_FFT::start()
  2854. {
  2855.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  2856. }
  2857.  
  2858. inline void Arts::Synth_STEREO_PITCH_SHIFT_FFT::stop()
  2859. {
  2860.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  2861. }
  2862.  
  2863. inline void Arts::Synth_STEREO_PITCH_SHIFT_FFT::streamInit()
  2864. {
  2865.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  2866. }
  2867.  
  2868. inline void Arts::Synth_STEREO_PITCH_SHIFT_FFT::streamStart()
  2869. {
  2870.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  2871. }
  2872.  
  2873. inline void Arts::Synth_STEREO_PITCH_SHIFT_FFT::streamEnd()
  2874. {
  2875.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  2876. }
  2877.  
  2878. inline float Arts::Synth_STEREO_PITCH_SHIFT_FFT::speed()
  2879. {
  2880.     return _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_cache)->speed():static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_method_call())->speed();
  2881. }
  2882.  
  2883. inline void Arts::Synth_STEREO_PITCH_SHIFT_FFT::speed(float _newValue)
  2884. {
  2885.      _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_cache)->speed(_newValue):static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_method_call())->speed(_newValue);
  2886. }
  2887.  
  2888. inline float Arts::Synth_STEREO_PITCH_SHIFT_FFT::scaleFactor()
  2889. {
  2890.     return _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_cache)->scaleFactor():static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_method_call())->scaleFactor();
  2891. }
  2892.  
  2893. inline void Arts::Synth_STEREO_PITCH_SHIFT_FFT::scaleFactor(float _newValue)
  2894. {
  2895.      _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_cache)->scaleFactor(_newValue):static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_method_call())->scaleFactor(_newValue);
  2896. }
  2897.  
  2898. inline long Arts::Synth_STEREO_PITCH_SHIFT_FFT::frameSize()
  2899. {
  2900.     return _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_cache)->frameSize():static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_method_call())->frameSize();
  2901. }
  2902.  
  2903. inline void Arts::Synth_STEREO_PITCH_SHIFT_FFT::frameSize(long _newValue)
  2904. {
  2905.      _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_cache)->frameSize(_newValue):static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_method_call())->frameSize(_newValue);
  2906. }
  2907.  
  2908. inline long Arts::Synth_STEREO_PITCH_SHIFT_FFT::oversample()
  2909. {
  2910.     return _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_cache)->oversample():static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_method_call())->oversample();
  2911. }
  2912.  
  2913. inline void Arts::Synth_STEREO_PITCH_SHIFT_FFT::oversample(long _newValue)
  2914. {
  2915.      _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_cache)->oversample(_newValue):static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_method_call())->oversample(_newValue);
  2916. }
  2917.  
  2918. inline Arts::AutoSuspendState Arts::Synth_STEREO_FIR_EQUALIZER::autoSuspend()
  2919. {
  2920.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  2921. }
  2922.  
  2923. inline void Arts::Synth_STEREO_FIR_EQUALIZER::start()
  2924. {
  2925.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  2926. }
  2927.  
  2928. inline void Arts::Synth_STEREO_FIR_EQUALIZER::stop()
  2929. {
  2930.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  2931. }
  2932.  
  2933. inline void Arts::Synth_STEREO_FIR_EQUALIZER::streamInit()
  2934. {
  2935.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  2936. }
  2937.  
  2938. inline void Arts::Synth_STEREO_FIR_EQUALIZER::streamStart()
  2939. {
  2940.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  2941. }
  2942.  
  2943. inline void Arts::Synth_STEREO_FIR_EQUALIZER::streamEnd()
  2944. {
  2945.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  2946. }
  2947.  
  2948. inline std::vector<Arts::GraphPoint> * Arts::Synth_STEREO_FIR_EQUALIZER::frequencies()
  2949. {
  2950.     return _cache?static_cast<Arts::Synth_STEREO_FIR_EQUALIZER_base*>(_cache)->frequencies():static_cast<Arts::Synth_STEREO_FIR_EQUALIZER_base*>(_method_call())->frequencies();
  2951. }
  2952.  
  2953. inline void Arts::Synth_STEREO_FIR_EQUALIZER::frequencies(const std::vector<Arts::GraphPoint>& _newValue)
  2954. {
  2955.      _cache?static_cast<Arts::Synth_STEREO_FIR_EQUALIZER_base*>(_cache)->frequencies(_newValue):static_cast<Arts::Synth_STEREO_FIR_EQUALIZER_base*>(_method_call())->frequencies(_newValue);
  2956. }
  2957.  
  2958. inline long Arts::Synth_STEREO_FIR_EQUALIZER::taps()
  2959. {
  2960.     return _cache?static_cast<Arts::Synth_STEREO_FIR_EQUALIZER_base*>(_cache)->taps():static_cast<Arts::Synth_STEREO_FIR_EQUALIZER_base*>(_method_call())->taps();
  2961. }
  2962.  
  2963. inline void Arts::Synth_STEREO_FIR_EQUALIZER::taps(long _newValue)
  2964. {
  2965.      _cache?static_cast<Arts::Synth_STEREO_FIR_EQUALIZER_base*>(_cache)->taps(_newValue):static_cast<Arts::Synth_STEREO_FIR_EQUALIZER_base*>(_method_call())->taps(_newValue);
  2966. }
  2967.  
  2968. inline Arts::Widget Arts::StereoFirEqualizerGuiFactory::createGui(Arts::Object runningObject)
  2969. {
  2970.     return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
  2971. }
  2972.  
  2973. inline Arts::AutoSuspendState Arts::Synth_FREEVERB::autoSuspend()
  2974. {
  2975.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  2976. }
  2977.  
  2978. inline void Arts::Synth_FREEVERB::start()
  2979. {
  2980.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  2981. }
  2982.  
  2983. inline void Arts::Synth_FREEVERB::stop()
  2984. {
  2985.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  2986. }
  2987.  
  2988. inline void Arts::Synth_FREEVERB::streamInit()
  2989. {
  2990.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  2991. }
  2992.  
  2993. inline void Arts::Synth_FREEVERB::streamStart()
  2994. {
  2995.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  2996. }
  2997.  
  2998. inline void Arts::Synth_FREEVERB::streamEnd()
  2999. {
  3000.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3001. }
  3002.  
  3003. inline float Arts::Synth_FREEVERB::roomsize()
  3004. {
  3005.     return _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->roomsize():static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->roomsize();
  3006. }
  3007.  
  3008. inline void Arts::Synth_FREEVERB::roomsize(float _newValue)
  3009. {
  3010.      _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->roomsize(_newValue):static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->roomsize(_newValue);
  3011. }
  3012.  
  3013. inline float Arts::Synth_FREEVERB::damp()
  3014. {
  3015.     return _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->damp():static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->damp();
  3016. }
  3017.  
  3018. inline void Arts::Synth_FREEVERB::damp(float _newValue)
  3019. {
  3020.      _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->damp(_newValue):static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->damp(_newValue);
  3021. }
  3022.  
  3023. inline float Arts::Synth_FREEVERB::wet()
  3024. {
  3025.     return _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->wet():static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->wet();
  3026. }
  3027.  
  3028. inline void Arts::Synth_FREEVERB::wet(float _newValue)
  3029. {
  3030.      _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->wet(_newValue):static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->wet(_newValue);
  3031. }
  3032.  
  3033. inline float Arts::Synth_FREEVERB::dry()
  3034. {
  3035.     return _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->dry():static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->dry();
  3036. }
  3037.  
  3038. inline void Arts::Synth_FREEVERB::dry(float _newValue)
  3039. {
  3040.      _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->dry(_newValue):static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->dry(_newValue);
  3041. }
  3042.  
  3043. inline float Arts::Synth_FREEVERB::width()
  3044. {
  3045.     return _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->width():static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->width();
  3046. }
  3047.  
  3048. inline void Arts::Synth_FREEVERB::width(float _newValue)
  3049. {
  3050.      _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->width(_newValue):static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->width(_newValue);
  3051. }
  3052.  
  3053. inline float Arts::Synth_FREEVERB::mode()
  3054. {
  3055.     return _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->mode():static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->mode();
  3056. }
  3057.  
  3058. inline void Arts::Synth_FREEVERB::mode(float _newValue)
  3059. {
  3060.      _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->mode(_newValue):static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->mode(_newValue);
  3061. }
  3062.  
  3063. inline Arts::Widget Arts::FreeverbGuiFactory::createGui(Arts::Object runningObject)
  3064. {
  3065.     return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
  3066. }
  3067.  
  3068. inline Arts::AutoSuspendState Arts::Effect_WAVECAPTURE::autoSuspend()
  3069. {
  3070.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3071. }
  3072.  
  3073. inline void Arts::Effect_WAVECAPTURE::start()
  3074. {
  3075.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3076. }
  3077.  
  3078. inline void Arts::Effect_WAVECAPTURE::stop()
  3079. {
  3080.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3081. }
  3082.  
  3083. inline void Arts::Effect_WAVECAPTURE::streamInit()
  3084. {
  3085.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3086. }
  3087.  
  3088. inline void Arts::Effect_WAVECAPTURE::streamStart()
  3089. {
  3090.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3091. }
  3092.  
  3093. inline void Arts::Effect_WAVECAPTURE::streamEnd()
  3094. {
  3095.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3096. }
  3097.  
  3098. inline std::string Arts::Effect_WAVECAPTURE::filename()
  3099. {
  3100.     return _cache?static_cast<Arts::Effect_WAVECAPTURE_base*>(_cache)->filename():static_cast<Arts::Effect_WAVECAPTURE_base*>(_method_call())->filename();
  3101. }
  3102.  
  3103. inline void Arts::Effect_WAVECAPTURE::filename(const std::string& _newValue)
  3104. {
  3105.      _cache?static_cast<Arts::Effect_WAVECAPTURE_base*>(_cache)->filename(_newValue):static_cast<Arts::Effect_WAVECAPTURE_base*>(_method_call())->filename(_newValue);
  3106. }
  3107.  
  3108. inline Arts::Direction Arts::StereoVolumeControlGui::direction()
  3109. {
  3110.     return _cache?static_cast<Arts::LayoutBox_base*>(_cache)->direction():static_cast<Arts::LayoutBox_base*>(_method_call())->direction();
  3111. }
  3112.  
  3113. inline void Arts::StereoVolumeControlGui::direction(Arts::Direction _newValue)
  3114. {
  3115.      _cache?static_cast<Arts::LayoutBox_base*>(_cache)->direction(_newValue):static_cast<Arts::LayoutBox_base*>(_method_call())->direction(_newValue);
  3116. }
  3117.  
  3118. inline long Arts::StereoVolumeControlGui::spacing()
  3119. {
  3120.     return _cache?static_cast<Arts::LayoutBox_base*>(_cache)->spacing():static_cast<Arts::LayoutBox_base*>(_method_call())->spacing();
  3121. }
  3122.  
  3123. inline void Arts::StereoVolumeControlGui::spacing(long _newValue)
  3124. {
  3125.      _cache?static_cast<Arts::LayoutBox_base*>(_cache)->spacing(_newValue):static_cast<Arts::LayoutBox_base*>(_method_call())->spacing(_newValue);
  3126. }
  3127.  
  3128. inline long Arts::StereoVolumeControlGui::layoutmargin()
  3129. {
  3130.     return _cache?static_cast<Arts::LayoutBox_base*>(_cache)->layoutmargin():static_cast<Arts::LayoutBox_base*>(_method_call())->layoutmargin();
  3131. }
  3132.  
  3133. inline void Arts::StereoVolumeControlGui::layoutmargin(long _newValue)
  3134. {
  3135.      _cache?static_cast<Arts::LayoutBox_base*>(_cache)->layoutmargin(_newValue):static_cast<Arts::LayoutBox_base*>(_method_call())->layoutmargin(_newValue);
  3136. }
  3137.  
  3138. inline void Arts::StereoVolumeControlGui::addWidget(Arts::Widget widget, long stretch, long align)
  3139. {
  3140.      _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addWidget(widget, stretch, align):static_cast<Arts::LayoutBox_base*>(_method_call())->addWidget(widget, stretch, align);
  3141. }
  3142.  
  3143. inline void Arts::StereoVolumeControlGui::addWidget(Arts::Widget widget, long stretch)
  3144. {
  3145.      _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addWidget(widget, stretch):static_cast<Arts::LayoutBox_base*>(_method_call())->addWidget(widget, stretch);
  3146. }
  3147.  
  3148. inline void Arts::StereoVolumeControlGui::addWidget(Arts::Widget widget)
  3149. {
  3150.      _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addWidget(widget):static_cast<Arts::LayoutBox_base*>(_method_call())->addWidget(widget);
  3151. }
  3152.  
  3153. inline void Arts::StereoVolumeControlGui::insertWidget(long position, Arts::Widget widget, long stretch, long align)
  3154. {
  3155.      _cache?static_cast<Arts::LayoutBox_base*>(_cache)->insertWidget(position, widget, stretch, align):static_cast<Arts::LayoutBox_base*>(_method_call())->insertWidget(position, widget, stretch, align);
  3156. }
  3157.  
  3158. inline void Arts::StereoVolumeControlGui::insertWidget(long position, Arts::Widget widget, long stretch)
  3159. {
  3160.      _cache?static_cast<Arts::LayoutBox_base*>(_cache)->insertWidget(position, widget, stretch):static_cast<Arts::LayoutBox_base*>(_method_call())->insertWidget(position, widget, stretch);
  3161. }
  3162.  
  3163. inline void Arts::StereoVolumeControlGui::insertWidget(long position, Arts::Widget widget)
  3164. {
  3165.      _cache?static_cast<Arts::LayoutBox_base*>(_cache)->insertWidget(position, widget):static_cast<Arts::LayoutBox_base*>(_method_call())->insertWidget(position, widget);
  3166. }
  3167.  
  3168. inline void Arts::StereoVolumeControlGui::addStretch(long stretch)
  3169. {
  3170.      _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addStretch(stretch):static_cast<Arts::LayoutBox_base*>(_method_call())->addStretch(stretch);
  3171. }
  3172.  
  3173. inline void Arts::StereoVolumeControlGui::addStretch()
  3174. {
  3175.      _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addStretch():static_cast<Arts::LayoutBox_base*>(_method_call())->addStretch();
  3176. }
  3177.  
  3178. inline void Arts::StereoVolumeControlGui::addSpace(long space)
  3179. {
  3180.      _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addSpace(space):static_cast<Arts::LayoutBox_base*>(_method_call())->addSpace(space);
  3181. }
  3182.  
  3183. inline void Arts::StereoVolumeControlGui::addStrut(long size)
  3184. {
  3185.      _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addStrut(size):static_cast<Arts::LayoutBox_base*>(_method_call())->addStrut(size);
  3186. }
  3187.  
  3188. inline void Arts::StereoVolumeControlGui::addSeparator(long stretch, long align)
  3189. {
  3190.      _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addSeparator(stretch, align):static_cast<Arts::LayoutBox_base*>(_method_call())->addSeparator(stretch, align);
  3191. }
  3192.  
  3193. inline void Arts::StereoVolumeControlGui::addSeparator(long stretch)
  3194. {
  3195.      _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addSeparator(stretch):static_cast<Arts::LayoutBox_base*>(_method_call())->addSeparator(stretch);
  3196. }
  3197.  
  3198. inline void Arts::StereoVolumeControlGui::addSeparator()
  3199. {
  3200.      _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addSeparator():static_cast<Arts::LayoutBox_base*>(_method_call())->addSeparator();
  3201. }
  3202.  
  3203. inline void Arts::StereoVolumeControlGui::addLine(long width, long space, long stretch, long align)
  3204. {
  3205.      _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addLine(width, space, stretch, align):static_cast<Arts::LayoutBox_base*>(_method_call())->addLine(width, space, stretch, align);
  3206. }
  3207.  
  3208. inline void Arts::StereoVolumeControlGui::addLine(long width, long space, long stretch)
  3209. {
  3210.      _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addLine(width, space, stretch):static_cast<Arts::LayoutBox_base*>(_method_call())->addLine(width, space, stretch);
  3211. }
  3212.  
  3213. inline void Arts::StereoVolumeControlGui::addLine(long width, long space)
  3214. {
  3215.      _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addLine(width, space):static_cast<Arts::LayoutBox_base*>(_method_call())->addLine(width, space);
  3216. }
  3217.  
  3218. inline long Arts::StereoVolumeControlGui::margin()
  3219. {
  3220.     return _cache?static_cast<Arts::Frame_base*>(_cache)->margin():static_cast<Arts::Frame_base*>(_method_call())->margin();
  3221. }
  3222.  
  3223. inline void Arts::StereoVolumeControlGui::margin(long _newValue)
  3224. {
  3225.      _cache?static_cast<Arts::Frame_base*>(_cache)->margin(_newValue):static_cast<Arts::Frame_base*>(_method_call())->margin(_newValue);
  3226. }
  3227.  
  3228. inline long Arts::StereoVolumeControlGui::linewidth()
  3229. {
  3230.     return _cache?static_cast<Arts::Frame_base*>(_cache)->linewidth():static_cast<Arts::Frame_base*>(_method_call())->linewidth();
  3231. }
  3232.  
  3233. inline void Arts::StereoVolumeControlGui::linewidth(long _newValue)
  3234. {
  3235.      _cache?static_cast<Arts::Frame_base*>(_cache)->linewidth(_newValue):static_cast<Arts::Frame_base*>(_method_call())->linewidth(_newValue);
  3236. }
  3237.  
  3238. inline long Arts::StereoVolumeControlGui::midlinewidth()
  3239. {
  3240.     return _cache?static_cast<Arts::Frame_base*>(_cache)->midlinewidth():static_cast<Arts::Frame_base*>(_method_call())->midlinewidth();
  3241. }
  3242.  
  3243. inline void Arts::StereoVolumeControlGui::midlinewidth(long _newValue)
  3244. {
  3245.      _cache?static_cast<Arts::Frame_base*>(_cache)->midlinewidth(_newValue):static_cast<Arts::Frame_base*>(_method_call())->midlinewidth(_newValue);
  3246. }
  3247.  
  3248. inline long Arts::StereoVolumeControlGui::framestyle()
  3249. {
  3250.     return _cache?static_cast<Arts::Frame_base*>(_cache)->framestyle():static_cast<Arts::Frame_base*>(_method_call())->framestyle();
  3251. }
  3252.  
  3253. inline void Arts::StereoVolumeControlGui::framestyle(long _newValue)
  3254. {
  3255.      _cache?static_cast<Arts::Frame_base*>(_cache)->framestyle(_newValue):static_cast<Arts::Frame_base*>(_method_call())->framestyle(_newValue);
  3256. }
  3257.  
  3258. inline Arts::Shape Arts::StereoVolumeControlGui::frameshape()
  3259. {
  3260.     return _cache?static_cast<Arts::Frame_base*>(_cache)->frameshape():static_cast<Arts::Frame_base*>(_method_call())->frameshape();
  3261. }
  3262.  
  3263. inline void Arts::StereoVolumeControlGui::frameshape(Arts::Shape _newValue)
  3264. {
  3265.      _cache?static_cast<Arts::Frame_base*>(_cache)->frameshape(_newValue):static_cast<Arts::Frame_base*>(_method_call())->frameshape(_newValue);
  3266. }
  3267.  
  3268. inline Arts::Shadow Arts::StereoVolumeControlGui::frameshadow()
  3269. {
  3270.     return _cache?static_cast<Arts::Frame_base*>(_cache)->frameshadow():static_cast<Arts::Frame_base*>(_method_call())->frameshadow();
  3271. }
  3272.  
  3273. inline void Arts::StereoVolumeControlGui::frameshadow(Arts::Shadow _newValue)
  3274. {
  3275.      _cache?static_cast<Arts::Frame_base*>(_cache)->frameshadow(_newValue):static_cast<Arts::Frame_base*>(_method_call())->frameshadow(_newValue);
  3276. }
  3277.  
  3278. inline Arts::StereoVolumeControlGui::StereoVolumeControlGui(Arts::Widget parent)
  3279.         : Arts::Object(StereoVolumeControlGui_base::_create())
  3280. {
  3281.     static_cast<Arts::Frame_base*>(_method_call())->constructor(parent);
  3282. }
  3283.  
  3284. inline long Arts::StereoVolumeControlGui::widgetID()
  3285. {
  3286.     return _cache?static_cast<Arts::Widget_base*>(_cache)->widgetID():static_cast<Arts::Widget_base*>(_method_call())->widgetID();
  3287. }
  3288.  
  3289. inline Arts::Widget Arts::StereoVolumeControlGui::parent()
  3290. {
  3291.     return _cache?static_cast<Arts::Widget_base*>(_cache)->parent():static_cast<Arts::Widget_base*>(_method_call())->parent();
  3292. }
  3293.  
  3294. inline void Arts::StereoVolumeControlGui::parent(Arts::Widget _newValue)
  3295. {
  3296.      _cache?static_cast<Arts::Widget_base*>(_cache)->parent(_newValue):static_cast<Arts::Widget_base*>(_method_call())->parent(_newValue);
  3297. }
  3298.  
  3299. inline long Arts::StereoVolumeControlGui::x()
  3300. {
  3301.     return _cache?static_cast<Arts::Widget_base*>(_cache)->x():static_cast<Arts::Widget_base*>(_method_call())->x();
  3302. }
  3303.  
  3304. inline void Arts::StereoVolumeControlGui::x(long _newValue)
  3305. {
  3306.      _cache?static_cast<Arts::Widget_base*>(_cache)->x(_newValue):static_cast<Arts::Widget_base*>(_method_call())->x(_newValue);
  3307. }
  3308.  
  3309. inline long Arts::StereoVolumeControlGui::y()
  3310. {
  3311.     return _cache?static_cast<Arts::Widget_base*>(_cache)->y():static_cast<Arts::Widget_base*>(_method_call())->y();
  3312. }
  3313.  
  3314. inline void Arts::StereoVolumeControlGui::y(long _newValue)
  3315. {
  3316.      _cache?static_cast<Arts::Widget_base*>(_cache)->y(_newValue):static_cast<Arts::Widget_base*>(_method_call())->y(_newValue);
  3317. }
  3318.  
  3319. inline long Arts::StereoVolumeControlGui::width()
  3320. {
  3321.     return _cache?static_cast<Arts::Widget_base*>(_cache)->width():static_cast<Arts::Widget_base*>(_method_call())->width();
  3322. }
  3323.  
  3324. inline void Arts::StereoVolumeControlGui::width(long _newValue)
  3325. {
  3326.      _cache?static_cast<Arts::Widget_base*>(_cache)->width(_newValue):static_cast<Arts::Widget_base*>(_method_call())->width(_newValue);
  3327. }
  3328.  
  3329. inline long Arts::StereoVolumeControlGui::height()
  3330. {
  3331.     return _cache?static_cast<Arts::Widget_base*>(_cache)->height():static_cast<Arts::Widget_base*>(_method_call())->height();
  3332. }
  3333.  
  3334. inline void Arts::StereoVolumeControlGui::height(long _newValue)
  3335. {
  3336.      _cache?static_cast<Arts::Widget_base*>(_cache)->height(_newValue):static_cast<Arts::Widget_base*>(_method_call())->height(_newValue);
  3337. }
  3338.  
  3339. inline bool Arts::StereoVolumeControlGui::visible()
  3340. {
  3341.     return _cache?static_cast<Arts::Widget_base*>(_cache)->visible():static_cast<Arts::Widget_base*>(_method_call())->visible();
  3342. }
  3343.  
  3344. inline void Arts::StereoVolumeControlGui::visible(bool _newValue)
  3345. {
  3346.      _cache?static_cast<Arts::Widget_base*>(_cache)->visible(_newValue):static_cast<Arts::Widget_base*>(_method_call())->visible(_newValue);
  3347. }
  3348.  
  3349. inline Arts::SizePolicy Arts::StereoVolumeControlGui::hSizePolicy()
  3350. {
  3351.     return _cache?static_cast<Arts::Widget_base*>(_cache)->hSizePolicy():static_cast<Arts::Widget_base*>(_method_call())->hSizePolicy();
  3352. }
  3353.  
  3354. inline void Arts::StereoVolumeControlGui::hSizePolicy(Arts::SizePolicy _newValue)
  3355. {
  3356.      _cache?static_cast<Arts::Widget_base*>(_cache)->hSizePolicy(_newValue):static_cast<Arts::Widget_base*>(_method_call())->hSizePolicy(_newValue);
  3357. }
  3358.  
  3359. inline Arts::SizePolicy Arts::StereoVolumeControlGui::vSizePolicy()
  3360. {
  3361.     return _cache?static_cast<Arts::Widget_base*>(_cache)->vSizePolicy():static_cast<Arts::Widget_base*>(_method_call())->vSizePolicy();
  3362. }
  3363.  
  3364. inline void Arts::StereoVolumeControlGui::vSizePolicy(Arts::SizePolicy _newValue)
  3365. {
  3366.      _cache?static_cast<Arts::Widget_base*>(_cache)->vSizePolicy(_newValue):static_cast<Arts::Widget_base*>(_method_call())->vSizePolicy(_newValue);
  3367. }
  3368.  
  3369. inline void Arts::StereoVolumeControlGui::show()
  3370. {
  3371.      _cache?static_cast<Arts::Widget_base*>(_cache)->show():static_cast<Arts::Widget_base*>(_method_call())->show();
  3372. }
  3373.  
  3374. inline void Arts::StereoVolumeControlGui::hide()
  3375. {
  3376.      _cache?static_cast<Arts::Widget_base*>(_cache)->hide():static_cast<Arts::Widget_base*>(_method_call())->hide();
  3377. }
  3378.  
  3379. inline std::string Arts::StereoVolumeControlGui::title()
  3380. {
  3381.     return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->title():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->title();
  3382. }
  3383.  
  3384. inline void Arts::StereoVolumeControlGui::title(const std::string& _newValue)
  3385. {
  3386.      _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->title(_newValue):static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->title(_newValue);
  3387. }
  3388.  
  3389. inline float Arts::StereoVolumeControlGui::dbmin()
  3390. {
  3391.     return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->dbmin():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->dbmin();
  3392. }
  3393.  
  3394. inline void Arts::StereoVolumeControlGui::dbmin(float _newValue)
  3395. {
  3396.      _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->dbmin(_newValue):static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->dbmin(_newValue);
  3397. }
  3398.  
  3399. inline float Arts::StereoVolumeControlGui::dbmax()
  3400. {
  3401.     return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->dbmax():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->dbmax();
  3402. }
  3403.  
  3404. inline void Arts::StereoVolumeControlGui::dbmax(float _newValue)
  3405. {
  3406.      _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->dbmax(_newValue):static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->dbmax(_newValue);
  3407. }
  3408.  
  3409. inline Arts::LevelMeter Arts::StereoVolumeControlGui::left()
  3410. {
  3411.     return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->left():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->left();
  3412. }
  3413.  
  3414. inline Arts::LevelMeter Arts::StereoVolumeControlGui::right()
  3415. {
  3416.     return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->right():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->right();
  3417. }
  3418.  
  3419. inline Arts::VolumeFader Arts::StereoVolumeControlGui::fader()
  3420. {
  3421.     return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->fader():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->fader();
  3422. }
  3423.  
  3424. inline Arts::Tickmarks Arts::StereoVolumeControlGui::levelmetertickmarks()
  3425. {
  3426.     return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->levelmetertickmarks():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->levelmetertickmarks();
  3427. }
  3428.  
  3429. inline Arts::Tickmarks Arts::StereoVolumeControlGui::volumefadertickmarks()
  3430. {
  3431.     return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->volumefadertickmarks():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->volumefadertickmarks();
  3432. }
  3433.  
  3434. inline Arts::Label Arts::StereoVolumeControlGui::label()
  3435. {
  3436.     return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->label():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->label();
  3437. }
  3438.  
  3439. inline bool Arts::StereoVolumeControlGui::couple()
  3440. {
  3441.     return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->couple():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->couple();
  3442. }
  3443.  
  3444. inline void Arts::StereoVolumeControlGui::couple(bool _newValue)
  3445. {
  3446.      _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->couple(_newValue):static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->couple(_newValue);
  3447. }
  3448.  
  3449. inline Arts::StereoVolumeControlGui::StereoVolumeControlGui(Arts::StereoVolumeControl svc)
  3450.         : Arts::Object(StereoVolumeControlGui_base::_create())
  3451. {
  3452.     static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->constructor(svc);
  3453. }
  3454.  
  3455. inline Arts::Widget Arts::StereoVolumeControlGuiFactory::createGui(Arts::Object runningObject)
  3456. {
  3457.     return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
  3458. }
  3459.  
  3460. #endif /* ARTSMODULESEFFECTS_H */
  3461.